zpr c++ quick reference

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
====== String ======


Klasa **string** jest kontenerem przeznaczonym do przechowywania łańcuchów znaków. Stanowi pewnego rodzaju opakowanie dla tablic znaków znanych z C, zawiera także wiele funkcji przydatnych do operowania na napisach. Przy programowaniu obiektowym klasa **string** zastępuje używanie tabic znaków i biblioteki cstring.

Aby móc używac obiektów typu **string** należy dołączyć do programu odpowiedni nagłówek:

<code cpp>
#include <string>
</code>

====== Metody klasy string ======

===== Spis =====

^ Podstawowe ^^
|[[string#Konstruktory|Konstruktor]]| Tworzy nowy obiekt |
|[[string#operator=|operator=]]	| Operator przypisania |
^ Iteratory ^^
|<code cpp>      iterator begin();
const_iterator begin() const;</code>|Zwraca iterator na pierwszy znak napisu |
|<code cpp>      iterator end();
const_iterator end() const;</code>|Zwraca iterator wskazujący na miejsce za ostatnim znakiem |
|<code cpp>      reverse_iterator rbegin();
const_reverse_iterator rbegin() const;</code>|Zwraca wsteczny iterator wskazujący na ostatni znak napisu |
|<code cpp>      reverse_iterator rend();
const_reverse_iterator rend() const;</code>|Zwraca wsteczny iterator wskazujący na miejsce przed pierwszym znakiem |
^Rozmiar^^
|<code cpp>size_t size() const;</code>|Zwraca ilość znaków w napisie (to samo co length())|
|<code cpp>size_t length() const;</code>|Zwraca ilość znaków w napisie (to samo co size())|
|<code cpp>size_t max_size ( ) const;</code>|Zwraca maksymalny dozwolony rozmiar napisu |
|<code cpp>void resize ( size_t n, char c );
void resize ( size_t n );</code>|Zmienia rozmiar napisu (skraca lub wydłuża). \\ Jeśli podany będzie dodatkowy argument //c//, po wydłużeniu napisu wolne miejsca zostaną wypełnione podanym znakiem. |
|<code cpp>size_t capacity ( ) const;</code>|Zwraca wielkość aktualnie zarezerwowanej dla napisu pamięci. //capacity >= size//. W razie potrzeby dodatkowa pamięć jest alokowana automatycznie. |
|<code cpp>void reserve ( size_t res_arg=0 );</code>|Wymusza zarezerwowanie ustalonej pamięci dla napisu. Jeśli podany argument jest mniejszy od aktualnej długości napisu, ilość pamięci jest zmniejszana do wielkości gwarantującej przechowanie dotychczasowego napisu. |
|<code cpp>void clear();</code>|Czyści napis |
|<code cpp>bool empty ( ) const;</code>|Sprawdza, czy napis jest pusty |
^Dostęp do znaków^^
|<code cpp>const char& operator[] ( size_t pos ) const;
      char& operator[] ( size_t pos );</code>|Zwraca znak na pozycji //pos//. |
|<code cpp>const char& at ( size_t pos ) const;
      char& at ( size_t pos );</code>|Zwraca znak na pozycji //pos//. Działa podobnie do operatora [], z tym że funkcja at() wykonuje sprawdzenie zakresu i w wypadku jego przekroczenia rzuca wyjątek //out_of_range//.|
^Modyfikacja^^
|[[string#operator+=]]	|Dopisuje znaki na końcu napisu |
|[[string#append]]	|Dopisuje znaki na końcu napisu |
|<code cpp>void push_back ( char c );</code>|Dodaje znak //c// na koniec napisu |
|[[string#assign]]	|Zastępuje dotychczasowy napis nowym |
|[[string#insert]]	|Wstawia dodatkowe znaki do napisu |
|[[string#erase]]	|Usuwa znaki z napisu |
|[[string#replace]]	|Zmienia część napisu |
|<code cpp>size_t copy ( char* s, size_t n, size_t pos = 0) const;</code>	|Kopiuje do tablicy //s// //n// znaków zaczynając od pozycji //pos//. Nie jest dopisywany znak '\0'. Odpowiednia ilość pamięci dla //s// powinna być przydzielona przed wywołaniem funkcji. |
|<code cpp>void swap ( string& str );</code>	|Zamienia zawartość aktualnego napisu z napisem //str//. |
^Operacje dodatkowe^^
|<code cpp>const char* c_str ( ) const;</code>	|Zwraca wskaźnik na tablicę znaków zakończoną zerem reprezentującą zawartość napisu. |
|<code cpp>const char* data ( ) const;</code>	|Zwraca wskaźnik na wewnętrzną tablicę przechowującą znaki napisu. Łańsuch nie zawiera kończącego zera. |
|[[string#find]]	|Wyszukuje pierwsze wystąpienie znaku/ciągu w napisie |
|[[string#find|rfind]]	|Wyszukuje ostatnie wystąpienie znaku/ciągu w napisie |
|[[string#find|find_first_of]]	|Wyszukuje pierwsze wystąpienie jednego z podanych znaków |
|[[string#find|find_last_of]]	|Wyszukuje ostatnie wystąpienie jednego z podanych znaków |
|[[string#find|find_first_not_of]]	|Wyszukuje pierwsze wystąpienie znaku nie podanego jako argument |
|[[string#find|find_last_not_of]]	|Wyszukuje ostatnie wystąpienie znaku nie podanego jako argument |
|<code>string substr ( size_t pos = 0, size_t n = npos ) const;</code>	|Zwraca podciąg aktualnego napisu zaczynający się na pozycji //pos// i składający się maksymalnie z //n// znaków |
|[[string#compare]]	|Porównuje dwa stringi |

===== Konstruktory =====

Istnieje kilka metod tworzenia obiektów klasy string.
\\
\\
<code cpp>explicit string ( );</code>
Tworzy pusty napis.
\\
\\
<code cpp>string ( const string& str );</code>
Kopiuje do nowego napisu zawartość już istniejącego.
\\
\\
<code cpp>string ( const string& str, size_t pos, size_t n = npos );</code>
Tworzy nowy napis i kopiuje do niego podciąg napisu podanego jako argument. Kopiowana jest część zaczynająca się na pozycji //pos// i zawierająca conajwyżej //n// znaków (jeśli napis jest krótszy niż //pos+n//, kopiowane są znaki od pozycji //pos// do końca napisu).
\\
\\
<code cpp>string ( const char * s, size_t n );</code>
Nowy napis jest tworzony poprzez kopiowanie //n// znaków z tablicy znaków wskazywanej przez //s//.
\\
\\
<code cpp>string ( const char * s );</code>
Nowy napis jest tworzony poprzez skopiowanie łańcucha znaków zakończonego zerem wskazywanego przez //s//.
\\
\\
<code cpp>string ( size_t n, char c );</code>
Tworzony jest napis zawierający //n// wystapień znaku //c//.
\\
\\
<code cpp>template<class InputIterator> 
    string (InputIterator begin, InputIterator end);</code>
Jeśli //InputIterator// jest typu całkowitego, jego argumenty są rzutowane na odpowiednie typy i wywoływany jest konstruktor wymieniony wyżej.
<code cpp>string(static_cast<size_t>(begin),static_cast<char>(end));</code>
W przeciwnym wypadku argumenty są traktowane jak iteratory i napis jest tworzony przez skopiowanie do stringa wszystkich elementów poczynając od //begin// a kończąc na elemencie poprzedzającym //end//.

===== Przypisanie =====

<code cpp>string& operator= ( const string& str );
string& operator= ( const char* s );
string& operator= ( char c );</code>

Operator przypisania dla napisów.
  * //str// - obiekt klasy string
  * //s// - łańcuch znaków zakończony zerem
  * //c// - po przypisaniu zawartość napisu stanowi pojedynczy znak

W każdym przypadku zwracaną wartością jest //*this//.

===== Modyfikacja =====

=== operator += ===
<code cpp>string& operator+= ( const string& str );
string& operator+= ( const char* s );
string& operator+= ( char c );</code>

Dopisuje na końcu napisu kopię danych podaną jako argument.

Rozszerzoną funkcjonalność oferuje funkcja append.

=== append ===

<code cpp>string& append ( const string& str );</code>

Dopisuje na końcu napisu kopię podanego argumentu.

<code cpp>string& append ( const string& str, size_t pos, size_t n );</code>
Dopisuje na końcu podciąg podanego argumentu zaczynający się na pozycji //pos// i składający się z //n// znaków (bądź mniej, jeśli napis się skończy wcześniej). Jeśli //pos// jest większy niż długość napisu zgłaszany jest wyjątek //out_of_range//

<code cpp>string& append ( const char * s, size_t n );</code>
Dopisuje na końcu pierwsze //n// znaków z tablicy wskazywanej przez //s//.

<code cpp>string& append ( const char * s );</code>

Dopisuje na końcu napis wskazywany przez s, kończący się znakiem '\0'.

<code cpp>string& append ( size_t n, char c );</code>

Dopisuje na końcu //n// razy znak //c//.

<code cpp>template<class InputIterator> string& append (InputIterator first, InputIterator last);</code>

Dopisuje na końcu wszystie znaki zaczynając od wskazywanego przez //first// a kończąc na znaku poprzedzającym //last//.

=== assign ===

<code cpp>string& assign ( const string& str );
string& assign ( const string& str, size_t pos, size_t n );
string& assign ( const char* s, size_t n );
string& assign ( const char* s );
string& assign ( size_t n, char c );
template <class InputIterator>
   string& assign ( InputIterator first, InputIterator last );</code>

Działanie assign polega na przypisaniu do napisu zawartości podanej jako argument. Argumenty interpretowane są identycznie jak w funkcji append.

=== insert ===

<code cpp>string& insert ( size_t pos1, const string& str );
Wstawia cały napis //str// na pozycji //pos1//.

<code cpp>string& insert ( size_t pos1, const string& str, size_t pos2, size_t n );</code>
Wstawia do napisu na pozycji //pos1// podciąg napisu //str// zaczynający się na pozycji //pos2// i zawierający do //n// znaków.

<code cpp>string& insert ( size_t pos1, const char * s, size_t n );</code>
Wstawia na pozycji //pos1// pierwsze //n// znaków z tablicy //s//.

<code cpp>string& insert ( size_t pos1, const char * s );</code>
Wstawia na pozycji //pos1// cały napis wskazywany przez //s// (napis musi być zakończony znakiem '\0').

<code cpp>string& insert ( size_t pos1, size_t n, char c );</code>
Wstawia na pozycji //pos1// //n// znaków //c//.

<code cpp>iterator insert ( iterator p, char c );</code>
Wstawia na pozycji wskazywanej przez iterator //p// znak //c//. Zwracany jest iterator na wstawiony znak.

<code cpp>void insert ( iterator p, size_t n, char c );</code>
Wstawia na pozycji wskazywanej przez iterator //p// //n// znaków //c//.

<code cpp>template<class InputIterator> void insert (iterator p, InputIterator first, InputIterator last);</code>
Wstawia na pozycji wskazywanej przez iterator //p// wszystkie znaki zaczynając od wskazywanego przez //first//, kończąc na znaku poprzedzającym //last//.

=== erase ===

<code cpp>string& erase ( size_t pos = 0, size_t n = npos );</code>
Usuwa z napisu //n// znaków zaczynając od tego na pozycji //pos//. Jeśli //n// większe od długości napisu, usuwane są znaki do końca napisu.

<code cpp>iterator erase ( iterator p );</code>
Usuwa jeden znak, wskazywany przez iterator //p//.

<code cpp>iterator erase ( iterator first, iterator last );</code>
Usuwa znaki zaczynając od tego wskazywanego przez //first// a kończac na poprzedzającym //last//.

=== replace ===

Zamienia część napisu na inną, podaną jako argument. Większość funkcji występuje w dwóch wersjach - pierwsza z nich określa fragment napisu do zmiany poprzez podanie pozycji pierwszego znaku //pos1// oraz długości //n1//, druga określa go poprzez podanie iteratorów //i1// i //i2//.

<code cpp>string& replace ( size_t pos1, size_t n1, const string& str );
string& replace ( iterator i1, iterator i2, const string& str );</code>
Wybrany fragment jest zamieniany na cały napis //str//.

<code cpp>string& replace ( size_t pos1, size_t n1, const string& str, size_t pos2, size_t n2 );</code>
Wybrany fragment jest zamieniany na podciąg napisu //str// zaczynający się na pozycji //pos2// i zawierający do //n2// znaków.

<code cpp>string& replace ( size_t pos1, size_t n1, const char * s, size_t n2 );
string& replace ( iterator i1, iterator i2, const char * s, size_t n2 );</code>
Wybrany fragment jest zamieniany na pierwsze //n2// znaków z tablicy //s//.

<code cpp>string& replace ( size_t pos1, size_t n1, const char * s );
string& replace ( iterator i1, iterator i2, const char * s );</code>
Wybrany fragment jest zamieniany na napis wskazywany przez //s// (zakończony znakiem '\0').

<code cpp>string& replace ( size_t pos1, size_t n1, size_t n2, char c );
string& replace ( iterator i1, iterator i2, size_t n2, char c );</code>
Wybrany fragment jest zamieniany na //n2// wystąpień znaku //c//.

<code cpp>template<class InputIterator> string& replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2);</code>
Wybrany fragment jest zamieniany na znaki znajdujące się pomiedzy iteratorami //j1// i //j2//.

===== Operacje dodatkowe =====

=== find ===

Do wyszukiwania podciągów w napisie służą dwie grupy funkcji. Pierwsza z nich wyszukuje cały napis podany jako argument, druga służy do wyszukiwania wystąpień dowolnego znaku z podanego napisu.

<code cpp>size_t find ( const string& str, size_t pos = 0 ) const;
size_t find ( const char* s, size_t pos, size_t n ) const;
size_t find ( const char* s, size_t pos = 0 ) const;
size_t find ( char c, size_t pos = 0 ) const;</code>

Wyszukaj pierwsze wystąpienie podanego ciągu w napisie. W czasie wyszukiwania w bieżącym napisie brane pod uwagę są tylko znaki od pozycji //pos//. Jeśli został użyty parametr //n//, oznacza on liczbę znaków w tablicy wskazywanej przez //s//, w przeciwnym wypadku //s// powinno wskazywać na napis zakończony zerem.

W celu wyszukania ostatniego wystąpienia danego ciągu należy użyć funkcji rfind o identycznej składni.

<code cpp>size_t find_first_of ( const string& str, size_t pos = 0 ) const;
size_t find_first_of ( const char* s, size_t pos, size_t n ) const;
size_t find_first_of ( const char* s, size_t pos = 0 ) const;
size_t find_first_of ( char c, size_t pos = 0 ) const;</code>

Wyszukaj pierwsze wystąpienie dowolnego znaku znajdującego się w podanym ciągu. Parametry mają takie samo znaczenie jak przy funkcji //find//.

Pozostałe 3 wersje tej funkcji to:
  * find_last_of - wyszukuje ostatnie wystąpienie dowolnego znaku z podanego ciągu
  * find_first_not_of - wyszukuje pierwszy znak nie będący fragmentem podanego ciągu
  * find_last_not_of - jw, z tym że wyszukuje ostatni taki znak


=== compare ===

<code cpp>int compare ( const string& str ) const;</code>
<code cpp>int compare ( const char* s ) const;</code>

Porównuje cały napis z podanym argumentem. Równoważne z 
<code cpp>*this == str;
*this == s;</code>


<code cpp>int compare ( size_t pos1, size_t n1, const string& str ) const;
int compare ( size_t pos1, size_t n1, const char* s) const;</code>

Porównuje napis podany jako argument z podciągiem aktualnego napisu złożonego z //n1// znaków zaczynającym się na pozycji //pos1//. Równowazne z 
<code cpp>(*this).substr(pos1, n1) == str;
(*this).substr(pos1, n1) == s;</code>

<code cpp>int compare ( size_t pos1, size_t n1, const string& str, size_t pos2, size_t n2 ) const;</code>

Porównuje fragment napisu podanego jako argument z podciągiem aktualnego napisu złożonego z //n1// znaków zaczynającym się na pozycji //pos1//. Równowazne z 
<code cpp>(*this).substr(pos1, n1) == str.substr(pos2, n2);</code>

<code cpp>int compare ( size_t pos1, size_t n1, const char* s, size_t n2) const;</code>
Porównuje //n2// pierwszych znaków z tablicy //s// z podciągiem aktualnego napisu złożonego z //n1// znaków zaczynającym się na pozycji //pos1//.

===== Porównanie operacji na napisach w C i C++ =====

^ operacja ^ C ^ C++ ^
| Porównanie zawartości | strcmp(s1, s2) | s1 == s2 (!=, <, > etc) / s1.compare(s2, ...) |
| Dopisanie na koniec | strcat(s1, "...") | s1 += "..." / s1.append("...", ...) |
| Kopiowanie zawartości | strcpy(s1, s2) | s1 = s2 / s1.assign(s2) |
| Długość | strlen(s1) | s1.size() |
| Wyszukiwanie napisu | strstr(s1, "napis") | s1.find("napis")|
| Wyszukiwanie jednego ze znaków | strspn(s1, "abc") | s1.find_first_of("abc") |
| Podział na podnapisy | strtok(s1, " ") | brak |

===== Odnośniki =====

[[http://www.cplusplus.com/reference/string/string/|C++ Reference]] \\
[[http://pl.wikibooks.org/wiki/C%2B%2B:String|Wikibooks, biblioteka wolnych podręczników]] \\

----

 --- //[[maciek.slon@gmail.com|Maciej Stefańczyk]] 2008/12/11 21:52//
zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
