std::getline

Function: std::getline

std::getline is a powerful function in C++ that allows you to read input from a stream (such as std::cin) line by line. It's particularly useful when you need to handle input that contains whitespace or when you want to read an entire line of text at once. In this guide, we'll explore various examples of using std::getline in different scenarios.

Example 1: Basic Usage with std::cin

#include <iostream>
#include <string>

int main() {
    std::string input;
    std::cout << "Enter a line of text: ";
    std::getline(std::cin, input);
    std::cout << "You entered: " << input << std::endl;
    return 0;
}

Explanation

This example demonstrates the most basic usage of std::getline. It reads a line of text from the standard input (std::cin) and stores it in a std::string variable. The function will read until it encounters a newline character or reaches the end of the input.

Example 2: Reading Multiple Lines

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

int main() {
    std::vector<std::string> lines;
    std::string line;

    std::cout << "Enter multiple lines of text (Ctrl+D to finish on Unix, Ctrl+Z on Windows):\n";

    while (std::getline(std::cin, line)) {
        lines.push_back(line);
    }

    std::cout << "\nYou entered " << lines.size() << " lines:\n";
    for (const auto& l : lines) {
        std::cout << l << std::endl;
    }

    return 0;
}

Explanation

• This example shows how to use std::getline in a loop to read multiple lines of input.
• It stores each line in a std::vector<std::string>.
• The loop continues until the user signals the end of input (Ctrl+D on Unix-like systems or Ctrl+Z on Windows).
• After reading all lines, it displays the number of lines entered and prints each line.

Example 3: Using a Delimiter

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

int main() {
    std::string input = "apple,banana,cherry,date";
    std::istringstream iss(input);
    std::string fruit;

    std::cout << "Fruits:\n";
    while (std::getline(iss, fruit, ',')) {
        std::cout << "- " << fruit << std::endl;
    }

    return 0;
}

Explanation

• This example demonstrates using std::getline with a custom delimiter.
• We use an std::istringstream to read from a string instead of std::cin.
• The third argument to std::getline specifies ',' as the delimiter.
• This allows us to split the input string into separate fruits at each comma.

Example 4: Handling Empty Lines

#include <iostream>
#include <string>

int main() {
    std::string input;
    int lineCount = 0;

    std::cout << "Enter text (empty line to finish):\n";

    while (true) {
        std::getline(std::cin, input);
        if (input.empty()) {
            break;
        }
        ++lineCount;
        std::cout << "Line " << lineCount << ": " << input << std::endl;
    }

    std::cout << "Total non-empty lines: " << lineCount << std::endl;
    return 0;
}

Explanation

• This example shows how to handle empty lines when using std::getline.
• It reads lines until an empty line is encountered (when the user just presses Enter).
• It demonstrates how to check if a line is empty using the empty() method of std::string.
• This approach can be useful for processing multi-line input where an empty line signifies the end of input.

Additional Considerations

1. Error Handling: std::getline sets the stream's error state if it encounters an error (e.g., end of file). You can check this using std::cin.fail() or std::cin.eof().

2. Mixing with Other Input Methods: Be cautious when mixing std::getline with other input methods like std::cin >>. The newline character left in the input buffer can cause unexpected behavior.

3. Performance: For large inputs, consider using std::getline with a std::stringstream or reading chunks of data into a buffer for better performance.

Summary

std::getline is a versatile function for reading input in C++. It's particularly useful for:

• Reading entire lines of text, including whitespace.
• Processing input with custom delimiters.
• Handling multi-line input scenarios.

The examples provided cover basic usage with std::cin, reading multiple lines, using custom delimiters, and handling empty lines. When using std::getline, remember to consider error handling, potential interactions with other input methods, and performance implications for large inputs. With these considerations in mind, std::getline can greatly simplify many input processing tasks in C++ programs.

Related

• How does std::getline differ from std::cin
• Can std::getline handle multiple delimiters
• What are common pitfalls when using std::getline
• How can I use std::getline with std::string
• Is std::getline safe for reading from files