====== Η κλάση std::string ======

Η //standard// βιβλιοθήκη της C++ διαθέτει την κλάση [[http://www.cplusplus.com/reference/string/string/|std::string]]. Οποιοδήποτε αντικείμενο της κλάσης αυτής μπορείτε να το αντιμετωπίζετε σαν ένα δυναμικά μεταβαλλόμενο πίνακα από χαρακτήρες. Η κλάση //string// έχει το πλεονέκτημα ότι δεν χρειάζεται να σας απασχολεί η δέσμευση της απαραίτητης μνήμης για την αποθήκευση των αλφαριθμητικών. 

Δείτε το παρακάτω παράδειγμα χρήσης της κλάσης //string//:
<code cpp string.cpp>
int main(int argc, char *argv[]) {
  string str = "Hello World!";
  cout << str  << endl;
  str.append(" How are you?");
  cout << str << endl;
  
  str = "Hello Wordl!";
  str += " How are you?";
  cout << str << endl;
}
</code>

Οι βασικές μέθοδοι της κλάσης string είναι οι εξής:

===== Κατασκευαστές =====

| <code cpp>string();</code> | default constructor  | 
| <code cpp>string (const string& str);</code>  | copy constructor  |
| <code cpp>string (const string& str, size_t pos, size_t len = npos);</code> | substring constructor	 |
| <code cpp>string (const char* s);</code>  | from c-string constructor  |
| <code cpp>string (const char* s, size_t n);</code>  | from c-string sequence | 
| <code cpp>string (size_t n, char c);</code>  | fill with c |

Παράδειγμα χρήσης κατασκευαστών
<code cpp strings_constructor.cpp>
#include <iostream>
using namespace std;

int main() {
  string str = "Hello World!";
  string copy(str); 
  string substring(str, 0, 5);
  const char *p = str.c_str();
  string fromCString(p);
  string fromCSequence(p, 8);
  string fillwithDollars(5, '$');
  
  cout << str << endl;
  cout << copy << endl;
  cout << substring << endl;
  cout << p << endl;
  cout << fromCString << endl;
  cout << fromCSequence << endl;
  cout << fillwithDollars << endl;  
}
</code>

===== Μέθοδοι =====

==== Χωρητικότητα και μέγεθος αλφαριθμητικού ====

| <code cpp>size_t size() const;</code>   | Επιστρέφει το μέγεθος του string  |
| <code cpp>size_t length() const;</code>   | Μέθοδος ανάλογη της μεθόδου size  |
| <code cpp>size_t capacity() const;</code>  | Χωρητικότητα του αλφαριθμητικού (σε bytes)  |
| <code cpp>void resize (size_t n); και 
 void resize (size_t n, char c);</code> | Επεκτείνεται το αλφαριθμητικό ώστε να έχει νέο μέγεθος ''n''. |
| <code cpp>void reserve (size_t n = 0);</code>  | Μεταβάλλει τη χωρητικότητα του αλφαριθμητικού. |
| <code cpp>void clear();</code> | Διαγράφει τα περιεχόμενα του αλφαριθμητικού  |
| <code cpp>bool empty() const;</code> | Επιστρέφει //true// εάν το αλφαριθμητικό είναι άδειο. |

==== Πρόσβαση σε χαρακτήρες του αλφαριθμητικού ====

|  <code cpp>char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;</code>  | Επιστρέφει μία αναφορά στη θέση //pos// του string. |
|  <code cpp>char& at (size_t pos);
const char& at (size_t pos) const;</code>  | Επιστρέφει μία αναφορά στη θέση //pos// του string. Πετάει //out_of_range exception// εάν δοθεί τιμή εκτός των ορίων του πίνακα.  |
|  <code cpp>char& back();
const char& back() const;</code>  | Επιστρέφει μία αναφορά στον τελευταίο χαρακτήρα του //string//.  |
|  <code cpp>char& front();
const char& front() const;</code>  | Επιστρέφει μία αναφορά στον πρώτο χαρακτήρα του //string//.   |

Στις όλες παραπάνω περιπτώσεις εάν το //string// είναι //const// επιστρατεύεται η //const// έκδοση της συνάρτησης.

==== Διάτρεξη ====

|  <code cpp>iterator begin();
const_iterator begin() const;</code>  | Επιστρέφει έναν //iterator// που δείχνει στον πρώτο χαρακτήρα του //string//.  |
|  <code cpp>iterator end();
const_iterator end() const;</code>  | Επιστρέφει έναν //iterator// που δείχνει μετά τον τελευταίο χαρακτήρα του //string//.  |
|  <code cpp>reverse_iterator rbegin();
const_reverse_iterator rbegin() const;</code>  | Επιστρέφει έναν //reverse iterator// που δείχνει στον τελευταίο χαρακτήρα του //string//.  |
|  <code cpp>reverse_iterator rend();
const_reverse_iterator rend() const;</code>  | Επιστρέφει έναν //reverse iterator// που δείχνει πριν από τον πρώτο χαρακτήρα του //string//.   |

=== Παράδειγμα χρήσης iterator ===

<code cpp string_fw_iterator.cpp>
#include <iostream>
#include <string>
using namespace std;

int main (){
  string str = "Hello World!";
  for( string::iterator it=str.begin(); it!=str.end(); ++it)
    cout << *it;
  cout << endl;
}
</code>

=== Παράδειγμα χρήσης reverse_iterator ===

<code cpp string_rv_iterator.cpp>
#include <iostream>
#include <string>
using namespace std;

int main (){
  string str = "Hello World!";
  for (string::reverse_iterator rit=str.rbegin(); rit!=str.rend(); ++rit)
    cout << *rit;
  cout << endl;
}
</code>

==== Μεταβολή του αλφαριθμητικού ====

|  <code cpp>string& operator+= (const string& str);
string& operator+= (const char* s);
string& operator+= (char c);</code>  | Επεκτείνει το αλφαριθμητικό προσθέτοντας τους επιπλέον χαρακτήρες του ορίσματος στο τέλος του. Επιστρέφει μία αναφορά στο τρέχον αντικείμενο. |
|  <code cpp>string& append (const string& str);
string& append (const char* str);</code>  | Επεκτείνει το αλφαριθμητικό ενθέτοντας ένα αντίγραφο του //str// στο τέλος του.  |
|  <code cpp>string& assign (const string& str);
string& assign (const char* str)</code>  | Αντιγράφει το //str// στο string.  |
|  <code cpp>string& insert (size_t pos, const string& str);
string& insert (size_t pos, const char* str);</code>  | Ενθέτει ένα αντίγραφο του //str// στη θέση //pos// του //string//.  |
|  <code cpp>string& erase (size_t pos = 0, size_t len = npos);
iterator erase (iterator p);
iterator erase (iterator first, iterator last);</code>  | Διαγράφει μέρος του //string//, μειώνοντας το μήκος του.  |
|  <code cpp>string& replace (size_t pos,  size_t len,  const string& str);
string& replace (size_t pos,  size_t len,  const char* s);
string& replace (size_t pos,  size_t len,  const string& str,
                 size_t subpos, size_t sublen);
</code>  | Αντικαθιστά το υφιστάμενο //string// με το νέο //str// ξεκινώντας από την θέση //pos// του //string// και για μήκος //len//.   |
|  <code cpp>void swap (string& str);</code>  | Ανταλλάσει αμοιβαία το περιεχόμενο του τρέχοντος //string// με το περιοχόμενο του //string str//.  |

<code cpp append.cpp>
#include <iostream>
#include <string>
using namespace std;

int main () {
  string str="Hello";
  string str2=" ";
  char[] str3="World";
  string str4 = "!\n";

  str+=str2;
  str.append(str3);
  str.append(str4);
  cout << str;
}
</code>

<code cpp replace.cpp>
#include <iostream>
#include <string>
using namespace std;

int main () {
  string base="this is a test string.";
  string str2="n example";
  string str3="sample phrase";
  string str4="useful.";

  string str=base;                // "this is a test string."
  str.replace(9,5,str2);          // "this is an example string." (1)
  str.replace(19,6,str3,7,6);     // "this is an example phrase." (2)
  str.replace(8,10,"just a");     // "this is just a phrase."     (3)
  cout << str << endl;
}
</code>

<code cpp chicken.cpp>
#include <iostream>
#include <string>
using namespace std;

main (){
  string chicken ("chicken");
  string egg ("egg");
  cout << "Before the swap, chicken comes from " << chicken;
  cout << " and egg comes from " << egg << endl;

  chicken.swap (egg);
  cout << "After the swap, chicken comes from " << chicken;
  cout << " and egg comes from " << egg << endl;
}
</code>


==== Σύγκριση, αναζήτηση, εξαγωγή υπο-αλφαριθμητικών ====

|  <code cpp>const char* c_str() const;</code>  | Επιστρέφει ένα //C-string// από ένα αντικείμενο της κλάσης //string//.  |
|  <code cpp>const char* data() const;</code>  | Ανάλογη με την //c_str()// με την διαφορά ότι η σειρά χαρακτήρων που προκύπτει δεν τερματίζεται με τον χαρακτήρα '\0'.  |
|  <code cpp>size_t copy (char* s, size_t len, size_t pos = 0) const;</code>  | Αντιγράφει ένα υπο-//string// του τρέχοντος //string// στον πίνακα που δείχνει ο δείκτης //s//. |
|  <code cpp>size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* str, size_t pos = 0) const;
size_t find (const char* str, size_t pos, size_t n) const;
size_t find (char c, size_t pos = 0) const;
</code>  | Αναζητά στο //string// την πρώτη εμφάνιση του //string str// ή του χαρακτήρα //c// ξεκινώντας την αναζήτηση από την θέση pos.  |
| <code cpp>size_t rfind (const string& str, size_t pos = npos) const;
size_t rfind (const char* str, size_t pos = npos) const;
size_t rfind (const char* str, size_t pos, size_t n) const;
size_t rfind (char c, size_t pos = npos) const;
</code>  | Αναζητά στο //string// την τελευταία εμφάνιση του //string str// ή του χαρακτήρα //c// ξεκινώντας την αναζήτηση από την θέση //pos// και αγνοώντας όλους του χαρακτήρες που βρίσκονται μετά τη θέση //pos//.  |
|  <code cpp>string substr (size_t pos = 0, size_t len = npos) const;</code>  | Επιστρέφει ένα νέο αντικείμενο το οποίο αποτελεί υπο-//string// του τρέχοντος αντικειμένου, ξεκινώντας από την θέση pos και με μήκος len.  |
|  <code cpp>int compare (const string& str) const;
int compare (size_t pos, size_t len, const string& str) const;
int compare (const char* str) const;
int compare (size_t pos, size_t len, const char* str) const;</code>  | Συγκρίνει το τρέχον string με το δοθέν //string// ή με το υπο-//string// που ξεκινάει από την θέση //pos// του //str// και έχει μήκος //len//.  |

<code cpp cstring.cpp>
#include <iostream>
#include <cstring>
#include <string>
using namespace std;

int main () {
  string str ("Split this sentence to word tokens");
  char * cstr = new char [str.length()+1];
  strcpy (cstr, str.c_str());

  char * p = strtok (cstr," ");
  while (p!=0) {
    cout << p << '\n';
    p = strtok(NULL," ");
  }
  delete[] cstr;
}
</code>