Lesson Overview

Welcome! In this lesson, we'll delve into the basic string manipulation features of C++, which include string tokenization, string concatenation, trimming of whitespace from strings, and type conversion operations.

Understanding Stringstreams

The idea behind stringstream is to treat strings as streams. This way, we can perform input/output operations on strings just as we do with cin and cout. Stringstreams are very useful for parsing strings. Consider the following example:

#include<iostream>
#include<sstream>

int main(){
    std::stringstream ss;
    ss << "Hello World!";
    std::string hello;
    ss >> hello;
    std::cout << hello << std::endl;
    
    std::string world;
    ss >> world;
    std::cout << world << std::endl;
    
    return 0;
}

In the example above, we first declare a stringstream object ss. We then insert the string "Hello World!" into this object using the insertion operator <<. Then we declare a string hello and extract a portion of the string from ss into hello using the extraction operator >>. This operation sees a whitespace ' ' as the delimiter by default. So hello will get "Hello".

The same operation is performed for world, so world will get "World!".

The output of the code is:

Hello
World!
Tokenizing a String in C++

In C++, we can use a combination of std::istringstream and std::getline to tokenize a string, essentially splitting it into smaller parts or 'tokens'.

#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::string sentence = "C++ is an amazing language!";
    std::istringstream sstream(sentence);
    std::string buffer;
    
    while (std::getline(sstream, buffer, ' ')) {
        std::cout << buffer << std::endl;
    }
    
    return 0;
}

In the example above, we use a space as a delimiter to split the sentence into words. This operation will print each word in the sentence on a new line.

Exploring String Concatenation

In C++, the + operator or the append() function can concatenate strings into a larger string:

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello,";
    std::string str2 = " World!";
    std::string greeting = str1 + str2;
    std::cout << greeting << std::endl;  // Output: "Hello, World!"
    
    std::string str3 = " C++ is fun.";
    greeting.append(str3);
    std::cout << greeting << std::endl;  // Output: "Hello, World! C++ is fun."
    
    return 0;
}

In the example above, we use + and append() to construct a larger string from smaller strings.

Trimming Whitespaces from Strings

In C++, the std::ws manipulator can remove leading spaces from a string. However, to remove trailing spaces, no standard library function exists. Hence, we have to write a custom function to accomplish this:

#include <iostream>
#include <string>
#include <sstream>

std::string rtrim(std::string str) {
    while(str.size() && isspace(str.back())) str.pop_back();
    return str;
}

int main() {
    std::string str = "    Hello, World!    "; // string with leading and trailing spaces
    std::istringstream sstream(str);
    std::getline(sstream >> std::ws, str); // remove leading spaces
    str = rtrim(str); // remove trailing spaces
    std::cout << str << std::endl; // Output: "Hello, World!"
    
    return 0;
}

In this example, we use the std::ws manipulator to remove leading whitespaces, and a custom function rtrim() to remove trailing whitespaces from a string.

C++ Type Conversions

We can convert strings to numbers using functions like std::stoi (string to integer) and std::stof (string to float), and other data types to strings using std::to_string:

#include <iostream>
#include <string>

int main() {
    std::string num_str = "123";
    int num = std::stoi(num_str);
    std::cout << num << std::endl;  // Output: 123
    
    std::string float_str = "3.14";
    float pi = std::stof(float_str);
    std::cout << pi << std::endl;  // Output: 3.14
    
    int age = 20;
    std::string age_str = std::to_string(age);
    std::cout << "I am " << age_str << " years old." << std::endl; // Output: I am 20 years old.
    
    return 0;
}

In this code, we use std::stoi, std::stof, and std::to_string for type conversions.

Integrating String Tokenization, Concatenation, Trimming, and Type Conversions

In some cases, we may need to combine all the methods discussed:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

std::vector<int> split(const std::string &s, char delimiter) {
    std::vector<int> tokens;
    std::string token;
    std::istringstream tokenStream(s);
    while (std::getline(tokenStream, token, delimiter)) {
        tokens.push_back(std::stoi(token));
    }
    return tokens;
}

int main() {
    std::string numbers = "1,2,3,4,6";
    std::vector<int> num_vector = split(numbers, ',');
    int sum = 0;
    for(auto num: num_vector)
        sum+=num;
    float average = static_cast<float>(sum) / num_vector.size();
    std::cout << "The average is " << average << std::endl;  // Output: The average is 3.2
    
    return 0;
}

By integrating these methods, we can transform the string "1,2,3,4,6" into a vector of integers, calculate their average, and display the result.

Quick Recap and Next Steps

Great job! You've gained an overview of C++'s string manipulation features, including string concatenation, string tokenization, trimming whitespace from strings, and type conversions. Now, it's time to get hands-on with these concepts in the exercises that follow. Happy coding!

Previous
Sign up
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal