Usage of the string Class in C++

In C++, the string class is provided by the standard library (defined in the <string> header file) for convenient string (character array) manipulation. It encapsulates operations on character arrays, providing a rich set of member functions, thus avoiding the cumbersome and safety issues of manually managing character arrays in C (such as buffer overflows).

1. Basic Usage

1. Include the Header File

To use std::string, you need to include the header file:

#include &lt;string&gt;
using namespace std;  // Optional, to avoid writing std:: each time

2. Definition and Initialization

string s1;                  // Empty string
string s2 = "hello";        // Initialized with C-style string
string s3("world");         // Constructor initialization
string s4(5, 'a');          // String composed of 5 'a's ("aaaaa")
string s5 = s2;             // Copy initialization (s5 = "hello")
string s6(s2, 1, 3);        // From index 1 of s2, take 3 characters ("ell")

2. Common Member Functions

1. String Length and Capacity

length()/size(): Returns the length of the string (number of characters).
empty(): Checks if the string is empty (returnstrue when length is 0).
capacity(): Returns the maximum number of characters the current string can hold without reallocating memory (greater than or equal tosize()).
reserve(n): Pre-allocates memory to hold at leastn characters, avoiding frequent expansions.
clear(): Clears the string (length becomes 0, capacity remains unchanged).

string s = "hello";
cout &lt;&lt; s.length() &lt;&lt; endl;  // Output: 5
cout &lt;&lt; s.size() &lt;&lt; endl;    // Output: 5 (equivalent to length())
cout &lt;&lt; s.empty() &lt;&lt; endl;   // Output: 0 (false)
s.clear();
cout &lt;&lt; s.empty() &lt;&lt; endl;   // Output: 1 (true)

2. String Access

operator[]: Accesses the character at the specified index (no bounds checking, high efficiency).
at(index): Accesses the character at the specified index (with bounds checking, throwsout_of_range exception on out of bounds).
front(): Returns the first character (equivalent tos[0]).
back(): Returns the last character (equivalent tos[s.size()-1]).

string s = "hello";
cout &lt;&lt; s[1] &lt;&lt; endl;     // Output: 'e'
cout &lt;&lt; s.at(2) &lt;&lt; endl; // Output: 'l'
// s[10]  // Undefined behavior (no check)
// s.at(10)  // Throws exception (with check)
cout &lt;&lt; s.front() &lt;&lt; endl; // Output: 'h'
cout &lt;&lt; s.back() &lt;&lt; endl; // Output: 'o'

3. String Modification

operator+=/append(): Appends a string.
push_back(c): Adds a single character at the end.
insert(pos, str): Inserts the stringstr at the specified positionpos.
erase(pos, n): Deletesn characters starting from positionpos (ifn is omitted, deletes to the end).
replace(pos, n, str): Replacesn characters starting from positionpos withstr.
swap(s): Swaps the contents with another strings (efficient, no memory copy).

string s = "hello";
s += " world";   // s becomes "hello world"
s.append("!");   // s becomes "hello world!"
s.push_back('?'); // s becomes "hello world!?"
s.insert(5, ","); // Inserts "," at index 5 → "hello, world!?"
s.erase(5, 2);     // Deletes 2 characters from index 5 → "helloworld!?"
s.replace(5, 5, "java"); // Replaces 5 characters starting from index 5 with "java" → "hellojava!?"
string t = "cpp";
s.swap(t); // s becomes "cpp", t becomes "hellojava!?"

4. String Search

find(str, pos): Searches forstr starting from positionpos, returning the index of the first occurrence; returnsstring::npos if not found. (string::npos is usually defined as -1)
rfind(str, pos): Searches forstr in reverse starting from positionpos, returning the index of the last occurrence.
find_first_of(str): Finds the index of the first occurrence of any character instr<code>.
find_last_of(str): Finds the index of the last occurrence of any character instr<code>.

string s = "hello world, hello cpp";
size_t pos1 = s.find("hello");      // pos1 = 0
size_t pos2 = s.find("hello", 1);   // Starts searching from index 1 → pos2 = 13
size_t pos3 = s.find("java");       // Not found → pos3 = string::npos
// string::npos is usually defined as -1
if (pos3 == string::npos) {
    cout &lt;&lt; "Not found" &lt;&lt; endl;
}
size_t pos4 = s.rfind("hello");     // Reverse search for the last occurrence → pos4 = 13

5. String Substring

substr(pos, n): Extractsn characters starting from positionpos, returning a new string (ifn is omitted, extracts to the end).

string s = "hello world";
string sub1 = s.substr(6, 5);  // Takes 5 characters from index 6 → "world"
string sub2 = s.substr(6);     // Takes from index 6 to the end → "world"

6. Other Common Functions

c_str(): Returns a pointer to a C-style character array of the string (const char*), used for compatibility with C functions (likeprintf).
data(): Similar toc_str(), but since C++11, both are equivalent (returnsconst char*).
compare(str): Compares the current string withstr, returning:

0: equal;
positive: current string is greater;
negative: current string is smaller.

3. Non-Member Functions (Helper Functions)

operator+: Concatenates two strings (likes1 + s2).
operator>>/operator<<: Input and output strings (likecin >> s,cout << s).
getline(cin, s): Reads a line of string (including spaces,cin >> s<code> stops at spaces).
swap(s1, s2): Swaps two strings (same functionality as member functionswap).

string s1 = "hello", s2 = "world";
cout &lt;&lt; s1 + " " + s2 &lt;&lt; endl;  // Output: hello world
string s3;
getline(cin, s3); // Reads a line of input (like "hello world" fully read)
cout &lt;&lt; s3 &lt;&lt; endl;

4. Notes

string::npos: Is a static constant that indicates “not found” or “end”, usually the maximum value ofsize_t type.
Index starts from 0: Consistent with arrays, the first character index is 0.
Memory Management: string automatically manages memory, no need for manual release, avoiding memory leak issues of char*<code> in C.
Thread Safety: Multi-threaded read/write to the samestring object requires locking, otherwise it may lead to undefined behavior.

5. Application Scenarios

Processing user input text (like usernames, passwords).
String concatenation, splitting, replacing, and other text processing.
Combined with file operations (reading/writing string content).
Compatible with C-style strings (throughc_str() conversion).

string is the preferred tool for handling strings in C++, and its rich function interface greatly simplifies string operations while ensuring safety and efficiency.