Converting String Case in C++

Converting the case of characters in a std::string is a common operation in text processing. C++ provides functions in the <algorithm> and <cctype> headers to accomplish this task efficiently.

Here's how you can convert a string to uppercase or lowercase:

1#include <iostream>
2#include <string>
3#include <algorithm>
4#include <cctype>
5
6int main() {
7  std::string text{"Hello, World!"};
8
9  // Convert to uppercase
10  std::string uppercase{text};
11  std::ranges::transform(
12    uppercase, uppercase.begin(),
13    [](unsigned char c) {
14      return std::toupper(c);
15    });  
16
17  // Convert to lowercase
18  std::string lowercase{text};
19  std::ranges::transform(
20    lowercase, lowercase.begin(),
21    [](unsigned char c) {
22      return std::tolower(c);
23    });  
24
25  std::cout << "Original: " << text << '\n';
26  std::cout << "Uppercase: " << uppercase << '\n';
27  std::cout << "Lowercase: " << lowercase << '\n';
28}

1Original: Hello, World!
2Uppercase: HELLO, WORLD!
3Lowercase: hello, world!

Let's break down the approach:

1. We use std::ranges::transform() (C++20) to apply a transformation to each character.
2. The lambda function [](unsigned char c){ return std::toupper(c); } is used to convert each character to uppercase. We use unsigned char to avoid undefined behavior with negative char values.
3. std::toupper() and std::tolower() from <cctype> are used for the actual character conversion.

If you're using a pre-C++20 compiler, you can use std::transform() instead:

1std::transform(
2  text.begin(), text.end(), text.begin(),
3  [](unsigned char c) {
4    return std::toupper(c);
5  }
6);

Note that this method works well for ASCII characters, but it may not handle Unicode characters correctly. For proper Unicode support, you might need to use a library like ICU (International Components for Unicode).

Also, be aware that these functions modify the string in-place. If you need to preserve the original string, make a copy before transforming, as shown in the example.

Remember, when working with std::string, it's often more efficient to modify the string in-place rather than creating a new string for each operation. This approach minimizes memory allocations and copies, leading to better performance, especially for longer strings or frequent operations.