Introduction to Strings

In C++, a string is a sequence of characters that is used to represent textual data. Strings are commonly used for storing and manipulating text in programs.

In C++, strings are defined using the std::string class from the Standard Template Library (STL). To work with strings, you need to include the <string> header.

Here's an example of declaring and printing a string in C++:

1#include <iostream>
2
3int main() {
4  std::string greeting = "Hello, world!";
5  std::cout << greeting << std::endl;
6  return 0;
7}

In this example, we declare a string variable greeting and assign it the value "Hello, world!". We then use std::cout to print the string to the console, followed by a newline character (std::endl) to start a new line.

When you run this program, you will see the output:

1Hello, world!

This is a basic introduction to strings in C++. In the following lessons, we will explore more advanced concepts and operations related to strings.

xxxxxxxxxx

#include <iostream>

​

int main() {

  std::string greeting = "Hello, world!";

  std::cout << greeting << std::endl;

  return 0;

}

String Input and Output

In C++, you can read and write strings using the std::cin and std::cout objects from the iostream library.

To read a string from the user, you can use the std::getline function. This function reads a line of input until a newline character is encountered and stores it in a string variable.

Here's an example:

1#include <iostream>
2#include <string>
3
4int main() {
5  std::string input;
6
7  // Read string input from the user
8  std::cout << "Enter a string: ";
9  std::getline(std::cin, input);
10
11  // Print the input string
12  std::cout << "You entered: " << input << std::endl;
13
14  return 0;
15}

In this example, we declare a string variable input to store the user's input. We use std::getline to read a line of input from the user and store it in input. Finally, we use std::cout to print the input string.

You can try running this program and entering a string to see the result.

xxxxxxxxxx

#include <iostream>

#include <string>

​

int main() {

  std::string input;

​

  // Read string input from the user

  std::cout << "Enter a string: ";

  std::getline(std::cin, input);

​

  // Print the input string

  std::cout << "You entered: " << input << std::endl;

​

  return 0;

}

String Manipulation

String manipulation refers to the various operations that can be performed on strings to modify them. In C++, there are several ways to manipulate strings.

Length of a String

The length of a string can be obtained using the length() function. It returns the number of characters in the string.

Here's an example:

1std::string str = "Hello, World!";
2int length = str.length();

Accessing Characters

Individual characters in a string can be accessed using their index. The index starts at 0 for the first character and goes up to length() - 1 for the last character.

Here's an example:

1std::string str = "Hello, World!";
2char firstChar = str[0]; // Accessing the first character
3char lastChar = str[str.length() - 1]; // Accessing the last character

Substring

A substring is a portion of a larger string. The substr() function can be used to extract a substring from a string. It takes two parameters: the starting index and the length of the substring.

Here's an example:

1std::string str = "Hello, World!";
2std::string substring = str.substr(7, 5); // Extracting the substring starting from index 7 with length 5

Concatenation

Concatenation is the process of combining two or more strings into a single string. In C++, you can concatenate strings using the + operator.

Here's an example:

1std::string str1 = "Hello, ";
2std::string str2 = "World!";
3std::string concat = str1 + str2; // Concatenating str1 and str2

xxxxxxxxxx

#include <iostream>

#include <string>

​

int main() {

  std::string str = "Hello, World!";

​

  // Length of the string

  int length = str.length();

  std::cout << "Length: " << length << std::endl;

​

  // Accessing characters

  char firstChar = str[0];

  char lastChar = str[str.length() - 1];

  std::cout << "First character: " << firstChar << std::endl;

  std::cout << "Last character: " << lastChar << std::endl;

​

  // Substring

  std::string substring = str.substr(7, 5);

  std::cout << "Substring: " << substring << std::endl;

​

  // Concatenation

  std::string concat = str + " Welcome to C++!";

  std::cout << "Concatenated string: " << concat << std::endl;

​

  return 0;

}

String Comparison

In C++, comparing strings is done using the == operator. This operator compares the content of the two strings and returns true if they are equal, and false otherwise.

Here's an example:

1std::string str1 = "Hello";
2std::string str2 = "World";
3
4if (str1 == str2) {
5    std::cout << "The strings are equal." << std::endl;
6} else {
7    std::cout << "The strings are not equal." << std::endl;
8}

This code will output:

1The strings are not equal.

It's important to note that string comparison is case-sensitive. So, for example, "hello" and "Hello" will be considered different strings.

In addition to the == operator, you can also use other comparison operators such as !=, <, >, <=, and >= to compare strings based on their lexicographical order. These operators compare the strings character by character, starting from the first character.

1std::string str1 = "Hello";
2std::string str2 = "World";
3
4if (str1 < str2) {
5    std::cout << "str1 is less than str2." << std::endl;
6} else {
7    std::cout << "str1 is greater than or equal to str2." << std::endl;
8}

xxxxxxxxxx

#include <iostream>

#include <string>

​

int main() {

    std::string str1 = "Hello";

    std::string str2 = "World";

​

    if (str1 == str2) {

        std::cout << "The strings are equal." << std::endl;

    } else {

        std::cout << "The strings are not equal." << std::endl;

    }

​

    return 0;

}

String Searching and Substring

In C++, searching for substrings in strings can be done using the find() function or by using the find() function with the string::npos constant.

The find() function returns the position of the first occurrence of the substring within the string. If the substring is not found, it returns std::string::npos.

Here's an example:

1#include <iostream>
2#include <string>
3
4int main() {
5    std::string sentence = "Hello, world!";
6    std::string search = "world";
7
8    size_t found = sentence.find(search);
9
10    if (found != std::string::npos) {
11        std::cout << "Substring found at position: " << found << std::endl;
12    } else {
13        std::cout << "Substring not found." << std::endl;
14    }
15
16    return 0;
17}

In this example, we have a sentence that contains the substring "world". The find() function is used to search for the substring within the sentence. If the substring is found, it prints the position where the substring starts. Otherwise, it prints "Substring not found."

You can also use the rfind() function to search for the last occurrence of a substring in a string.

1#include <iostream>
2#include <string>
3
4int main() {
5    std::string sentence = "Hello, world! Hello, everyone!";
6    std::string search = "Hello";
7
8    size_t found = sentence.rfind(search);
9
10    if (found != std::string::npos) {
11        std::cout << "Last occurrence of substring found at position: " << found << std::endl;
12    } else {
13        std::cout << "Substring not found." << std::endl;
14    }
15
16    return 0;
17}

The rfind() function searches for the last occurrence of the substring within the string.

Other functions like find_first_of(), find_last_of(), and find_first_not_of() can be used to search for specific characters or sets of characters within a string.

1#include <iostream>
2#include <string>
3
4int main() {
5    std::string sentence = "Hello, world!";
6    std::string characters = "aeiou";
7
8    size_t found = sentence.find_first_of(characters);
9
10    if (found != std::string::npos) {
11        std::cout << "First vowel found at position: " << found << std::endl;
12    } else {
13        std::cout << "No vowel found." << std::endl;
14    }
15
16    return 0;
17}

The find_first_of() function searches for the first occurrence of any character from a set of characters within the string.

These are just some of the functions that can be used to search for substrings in strings in C++. There are many more functions available in the C++ Standard Library that provide different functionalities for manipulating strings.

String Conversion

Converting strings to other data types and vice versa is a common task in programming. In C++, you can convert a string to an integer using the std::stoi function and to a double using the std::stod function.

Here's an example:

1#include <iostream>
2#include <sstream>
3#include <string>
4
5int main() {
6    std::string str = "12345";
7
8    // Converting string to int
9    int num = std::stoi(str);
10    std::cout << "String to int: " << num << std::endl;
11
12    // Converting string to double
13    double decimal = std::stod(str);
14    std::cout << "String to double: " << decimal << std::endl;
15
16    // Converting int to string
17    int number = 67890;
18    std::string result = std::to_string(number);
19    std::cout << "Int to string: " << result << std::endl;
20
21    // Converting double to string
22    double pi = 3.14159;
23    std::ostringstream oss;
24    oss << pi;
25    std::string strpi = oss.str();
26    std::cout << "Double to string: " << strpi << std::endl;
27
28    return 0;
29}

In this example, we have a string str with the value "12345". We use the std::stoi function to convert it to an integer, and the std::stod function to convert it to a double. We also demonstrate converting an integer and a double back to strings using the std::to_string function and ostringstream respectively.

String conversion is useful in various scenarios, for example, when you need to process user input, parse data from files, or convert numeric values to strings for output. It allows you to work with different data types and perform operations specific to those types.

Keep in mind that the conversion functions may throw exceptions if the conversion fails. It's a good practice to handle possible exceptions to ensure your program behaves correctly.

xxxxxxxxxx

#include <iostream>

#include <sstream>

#include <string>

​

int main() {

    std::string str = "12345";

​

    // Converting string to int

    int num = std::stoi(str);

    std::cout << "String to int: " << num << std::endl;

​

    // Converting string to double

    double decimal = std::stod(str);

    std::cout << "String to double: " << decimal << std::endl;

​

    // Converting int to string

    int number = 67890;

    std::string result = std::to_string(number);

    std::cout << "Int to string: " << result << std::endl;

​

    // Converting double to string

    double pi = 3.14159;

    std::ostringstream oss;

    oss << pi;

    std::string strpi = oss.str();

    std::cout << "Double to string: " << strpi << std::endl;

​

    return 0;

}

String Concatenation

In C++, you can concatenate strings using the + operator or the += operator.

Here's an example:

1#include <iostream>
2#include <string>
3
4int main() {
5  std::string str1 = "Hello";
6  std::string str2 = "World!";
7
8  std::string result = str1 + str2;
9
10  std::cout << result << std::endl;
11
12  return 0;
13}

In this example, we have two strings str1 and str2. We use the + operator to concatenate them and store the result in the result variable. Finally, we print the concatenated string result.

String concatenation is useful when you want to combine multiple strings into a single string. It allows you to build more complex strings by joining smaller segments together.

Note that when concatenating strings, a new string is created to hold the combined value. The original strings str1 and str2 remain unchanged.

You can also use the += operator to concatenate a string with another string and assign the result back to the original string.

Try experimenting with different strings and see how string concatenation works in C++.

xxxxxxxxxx

#include <iostream>

#include <string>

​

int main() {

  std::string str1 = "Hello";

  std::string str2 = "World!";

​

  std::string result = str1 + str2;

​

  std::cout << result << std::endl;

​

  return 0;

}

String Tokenization

String tokenization is the process of splitting a string into smaller parts or tokens based on a specific delimiter or set of delimiters. Each token represents a meaningful unit of information within the string.

In C++, there are multiple ways to tokenize a string:

• Using the std::stringstream class
• Using the std::string member functions
• Using the boost::tokenizer library

Let's explore each of these methods in more detail.

Tokenization using std::stringstream

The std::stringstream class provides a convenient way to split a string into tokens using streams. Here's an example:

1#include <iostream>
2#include <sstream>
3#include <vector>
4
5int main() {
6  std::string str = "Hello,World,How,Are,You";
7
8  std::vector<std::string> tokens;
9  std::stringstream ss(str);
10  std::string token;
11
12  while (std::getline(ss, token, ',')) {
13    tokens.push_back(token);
14  }
15
16  for (const auto& t : tokens) {
17    std::cout << t << std::endl;
18  }
19
20  return 0;
21}

xxxxxxxxxx

#include <iostream>

#include <sstream>

#include <vector>

​

int main() {

  std::string str = "Hello,World,How,Are,You";

​

  std::vector<std::string> tokens;

  std::stringstream ss(str);

  std::string token;

​

  while (std::getline(ss, token, ',')) {

    tokens.push_back(token);

  }

​

  for (const auto& t : tokens) {

    std::cout << t << std::endl;

  }

​

  return 0;

}

String Case Conversion

In C++, you can change the case of a string by converting all its characters to uppercase or lowercase.

To convert a string to uppercase, you can use the std::transform function from the <algorithm> header along with the ::toupper function from the <cctype> header. This function will convert each character in the string to its uppercase form.

To convert a string to lowercase, you can use the same std::transform function with the ::tolower function, which will convert each character to its lowercase form.

Here's an example:

1#include <iostream>
2#include <algorithm>
3#include <cctype>
4
5int main() {
6  std::string str = "Hello World";
7
8  // Convert to uppercase
9  std::transform(str.begin(), str.end(), str.begin(), ::toupper);
10  std::cout << "Uppercase: " << str << std::endl;
11
12  // Convert to lowercase
13  std::transform(str.begin(), str.end(), str.begin(), ::tolower);
14  std::cout << "Lowercase: " << str << std::endl;
15
16  return 0;
17}

In this example, we start with the string "Hello World". We use std::transform function along with ::toupper to convert the characters to uppercase, and then std::transform with ::tolower to convert the characters back to lowercase.

The output of the code snippet will be:

1Uppercase: HELLO WORLD
2Lowercase: hello world

xxxxxxxxxx

#include <iostream>

#include <algorithm>

#include <cctype>

​

int main() {

  std::string str = "Hello World";

​

  // Convert to uppercase

  std::transform(str.begin(), str.end(), str.begin(), ::toupper);

  std::cout << "Uppercase: " << str << std::endl;

​

  // Convert to lowercase

  std::transform(str.begin(), str.end(), str.begin(), ::tolower);

  std::cout << "Lowercase: " << str << std::endl;

​

  return 0;

}

String Formatting

String formatting allows you to control the appearance of strings when they are printed or displayed. In C++, you can use the std::cout object along with formatting manipulators to format strings.

One common use case for string formatting is to control the number of decimal places when printing floating-point numbers. For example, if you have a variable pi with the value 3.14159265359 and you want to display it with 2 decimal places, you can use the std::fixed and std::setprecision manipulators from the <iomanip> header. Here's an example:

1#include <iostream>
2#include <iomanip>
3
4int main() {
5  double pi = 3.14159265359;
6
7  // Format pi to display with 2 decimal places
8  std::cout << "Pi: " << std::fixed << std::setprecision(2) << pi << std::endl;
9
10  return 0;
11}

In this example, we start with a variable pi with the value of 3.14159265359. We use the std::cout object to display the string "Pi: " followed by the formatted value of pi. The std::fixed manipulator ensures that the number is displayed in fixed-point notation, and the std::setprecision manipulator sets the precision (number of decimal places) to 2.

The output of the code will be:

1Pi: 3.14

String formatting in C++ provides various other manipulators and options to control the appearance of strings, such as setting the width, alignment, padding, and more. You can explore the <iomanip> header for more information and options.

xxxxxxxxxx

#include <iostream>

#include <iomanip>

​

int main() {

  double pi = 3.14159265359;

​

  // Format pi to display with 2 decimal places

  std::cout << "Pi: " << std::fixed << std::setprecision(2) << pi << std::endl;

​

  return 0;

}