Strings in C ++
**Strings in C++**
In C++, strings can be handled in two primary ways: using **C-style character arrays** and the **`std::string`** class from the Standard Template Library (STL). Here's a structured overview:
---
**1. C-Style Strings**
- **Definition**: Arrays of characters terminated by a null character (`'\0'`).
- **Declaration**:
```cpp
char cstr1[] = "Hello"; // Automatically adds '\0'
char cstr2[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
```
- **Key Functions** (from `<cstring>`):
- `strlen(cstr)`: Returns length (excluding `'\0'`).
- `strcpy(dest, src)`: Copies `src` to `dest`.
- `strcat(dest, src)`: Appends `src` to `dest`.
- `strcmp(cstr1, cstr2)`: Compares lexicographically (returns 0 if equal).
- **Pitfalls**:
- Buffer overflow risks (e.g., `strcpy` without checking sizes).
- Manual memory management required.
---
**2. `std::string` Class**
- **Header**: `<string>`
- **Declaration**:
```cpp
#include <string>
std::string str = "Hello, C++!";
```
- **Key Features**:
- **Dynamic Memory Management**: Automatically resizes.
- **Concatenation**:
```cpp
std::string s1 = "Hello", s2 = "World";
std::string s3 = s1 + " " + s2; // "Hello World"
```
- **Common Methods**:
- `length()`/`size()`: Number of characters.
- `substr(pos, len)`: Extracts substring.
- `find("substr")`: Returns position of substring.
- `append(str)`: Adds to the end.
- **Safety**: Prevents buffer overflows.
---
**Conversion Between C-Style and `std::string`**
- **`std::string` to C-style**:
```cpp
const char* cstr = str.c_str(); // Requires null termination
```
- **C-style to `std::string`**:
```cpp
char cstr[] = "Hello";
std::string str(cstr); // Implicit conversion
```
---
**Input Handling**
- **C-Style** (risky):
```cpp
char buffer[50];
std::cin >> buffer; // Unsafe if input exceeds 49 chars
```
- **`std::string`** (safer):
```cpp
std::string input;
std::getline(std::cin, input); // Reads entire line
```
---
**Best Practices**
1. **Prefer `std::string`** for most use cases due to safety and convenience.
2. **Avoid Mixing Styles**: Use C-style strings only for legacy code or specific APIs.
3. **Pass by Reference**:
```cpp
void modifyString(std::string& str); // Efficient for large strings
```
---
**Example: Using `std::string`**
```cpp
#include <iostream>
#include <string>
int main() {
std::string name;
std::cout << "Enter your name: ";
std::getline(std::cin, name);
std::string greeting = "Hello, " + name + "!";
std::cout << greeting << std::endl;
if (greeting.find("Alice") != std::string::npos) {
std::cout << "Hi, Alice!" << std::endl;
}
return 0;
}
```
**Output**:
```
Enter your name: Alice
Hello, Alice!
Hi, Alice!
```
---
**Conclusion**: `std::string` is the modern, safer, and more flexible choice in C++. Use C-style strings only when necessary.
Comments
Post a Comment