# Strings In C++

## Understanding Strings in C++

Strings are a fundamental aspect of any programming language, and C++ is no different. Whether you're manipulating user input, reading files, or displaying messages, strings are essential. In C++, strings can be handled using C-style strings (character arrays) or the more advanced `std::string` class from the Standard Library. Let's dive into the intricacies of strings in C++.

### C-Style Strings (Character Arrays)

C-style strings are essentially arrays of characters terminated by a null character (`'\0'`). This null character signals the end of the string. Here's a breakdown of their usage:

#### Declaration and Initialization

You can declare a C-style string as an array of characters:

```cpp
char greeting[] = "Hello";
```

In memory, this string would be stored as follows:

```css
Address   Value
0x1000    'H'
0x1001    'e'
0x1002    'l'
0x1003    'l'
0x1004    'o'
0x1005    '\0'
```

#### Taking Input

To take input into a C-style string, you can use `cin` or `cin.getline`:

```cpp
#include <iostream>

int main() {
    char name[50];
    std::cout << "Enter your name: ";
    std::cin.getline(name, 50);
    std::cout << "Hello, " << name << "!" << std::endl;
    return 0;
}
```

### `std::string` Class

The `std::string` class provides a more convenient and powerful way to handle strings in C++. It abstracts away many of the complexities associated with C-style strings.

#### Declaration and Initialization

You can declare and initialize an `std::string` just like any other variable:

```cpp
#include <string>
#include <iostream>

int main() {
    std::string greeting = "Hello";
    std::cout << greeting << std::endl;
    return 0;
}
```

#### Taking Input

To take input into an `std::string`, you can use `cin` or `getline`:

```cpp
#include <iostream>
#include <string>

int main() {
    std::string name;
    std::cout << "Enter your name: ";
    std::getline(std::cin, name);
    std::cout << "Hello, " << name << "!" << std::endl;
    return 0;
}
```

### Memory Management

* **C-Style Strings**: Stored as arrays of characters with a null terminator. You need to manage memory manually, especially when dealing with dynamic allocation.
    
* `std::string`: Manages memory automatically. Internally, it uses dynamic memory allocation to handle strings of varying lengths efficiently.
    

### Common String Functions

Here are some commonly used functions for both C-style strings and `std::string`:

#### `length()` and `size()`

Both `length()` and `size()` return the number of characters in the string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::cout << "Length: " << str.length() << std::endl; // 13
    std::cout << "Size: " << str.size() << std::endl; // 13
    return 0;
}
```

#### `swap()`

This function swaps the contents of two strings.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";
    str1.swap(str2);
    std::cout << "str1: " << str1 << ", str2: " << str2 << std::endl; // str1: World, str2: Hello
    return 0;
}
```

#### `resize()`

This function resizes the string to the given number of characters.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    str.resize(5);
    std::cout << "Resized string: " << str << std::endl; // Hello
    return 0;
}
```

#### `find()`

This function finds a substring within the string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    size_t pos = str.find("World");
    if (pos != std::string::npos) {
        std::cout << "Found 'World' at position: " << pos << std::endl; // 7
    } else {
        std::cout << "'World' not found" << std::endl;
    }
    return 0;
}
```

#### `push_back()`

This function adds a character at the end of the string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello";
    str.push_back('!');
    std::cout << "String after push_back: " << str << std::endl; // Hello!
    return 0;
}
```

#### `pop_back()`

This function removes the last character from the string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello!";
    str.pop_back();
    std::cout << "String after pop_back: " << str << std::endl; // Hello
    return 0;
}
```

#### `clear()`

This function removes all characters from the string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello";
    str.clear();
    std::cout << "String after clear: '" << str << "'" << std::endl; // ''
    return 0;
}
```

### C-Style String Functions

#### `strncmp()`

This function compares the first `num` characters of two strings.

```cpp
#include <iostream>
#include <cstring>

int main() {
    const char* str1 = "Hello";
    const char* str2 = "Hello, World!";
    int result = strncmp(str1, str2, 5); // Compare first 5 characters
    if (result == 0) {
        std::cout << "Strings are equal" << std::endl;
    } else {
        std::cout << "Strings are not equal" << std::endl;
    }
    return 0;
}
```

#### `strncpy()`

This function copies up to `n` characters from the source string to the destination string.

```cpp
#include <iostream>
#include <cstring>

int main() {
    const char* src = "Hello, World!";
    char dest[6];
    strncpy(dest, src, 5);
    dest[5] = '\0'; // Null-terminate the destination string
    std::cout << "Destination string: " << dest << std::endl; // Hello
    return 0;
}
```

#### `strrchr()`

This function finds the last occurrence of a character in the string.

```cpp
#include <iostream>
#include <cstring>

int main() {
    const char* str = "Hello, World!";
    const char* pos = strrchr(str, 'o');
    if (pos != nullptr) {
        std::cout << "Last occurrence of 'o': " << pos - str << std::endl; // 8
    } else {
        std::cout << "'o' not found" << std::endl;
    }
    return 0;
}
```

#### `strcat()`

This function appends a copy of the source string to the destination string.

```cpp
#include <iostream>
#include <cstring>

int main() {
    char dest[20] = "Hello";
    const char* src = ", World!";
    strcat(dest, src);
    std::cout << "Concatenated string: " << dest << std::endl; // Hello, World!
    return 0;
}
```

### Additional String Functions

#### `replace()`

This function replaces part of the string with another string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    str.replace(7, 5, "Universe"); // Replace "World" with "Universe"
    std::cout << "Replaced string: " << str << std::endl; // Hello, Universe!
    return 0;
}
```

#### `substr()`

This function creates a substring from the given string.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::string sub = str.substr(7, 5); // Get substring "World"
    std::cout << "Substring: " << sub << std::endl; // World
    return 0;
}
```

#### `compare()`

This function compares two strings and returns an integer based on the comparison.

```cpp
#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";
    int result = str1.compare(str2);
    if (result == 0) {
        std::cout << "Strings are equal" << std::endl;
    } else if (result < 0) {
        std::cout << "str1 is less than str2" << std::endl;
    } else {
        std::cout << "str1 is greater than str2" << std::endl;
    }
    return 0;
}
```

#### `erase()`

This function removes part of the string