Getline Function in C++ | Syntax | Examples

In this tutorial, we will learn about getline function in C++. Firstly C++ is a versatile programming language known for its flexibility and power. It enables developers to create efficient and high-performance software applications by providing a wide range of tools and features. C++ combines the capabilities of both low-level programming, allowing direct memory manipulation, and high-level programming, offering advanced constructs like classes and objects for organized code design.

Usually, we opt for the cin function to gather user input, but this approach has limitations. To surpass these constraints, we turn to the getline function in C++. This function proves advantageous when we need to capture input spread across multiple lines and in various other scenarios as well.

Definition of Getline Function in C++

In C++, the getline function serves as a handy tool for reading lines of text. It allows programmers to retrieve entire lines from input sources, such as the keyboard or files. with getline, you can gather multiple words and spaces within a single line, stopping only when a newline character is encountered.

For instance, when used with the standard input, getline prompts users to input a line of text, collects it, and stores it as a string variable. This makes it especially useful when you want to capture input that might include spaces. Furthermore, getline can also be utilized to read lines from files, enabling the reading of content within those files on a line-by-line basis.

The function facilitates more flexible input handling compared to other methods. It lets you process entire lines of text in a single operation. This can simplify user interaction and streamline file-reading tasks.

Getline function syntax

#include <iostream>
#include <string>

int main() {
    std::string input;
    std::getline(input_stream, input, delimiter);
    return 0;
}

input_stream: This is the input stream you want to read from. It could be std::cin for standard input (keyboard) or an instance of std::ifstream for reading from a file.
input: You store the input line in a string.
delimiter (optional): This parameter specifies the delimiter character that marks the end of the line. By default, it’s set to the newline character (\n), which means the function reads until a newline is encountered. You can provide a different delimiter if needed.

How to use getline function with examples

1. Reading from Standard Input

When you run this program, it will prompt you to enter a line of text. It will read the entire line, including spaces, and then display what you entered.

#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;
}

Output:

Enter a line of text  
You entered: DeveloperHelps

2. Reading from a file

getline is also useful for reading lines from files. Here’s an example of reading lines from a file.

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream inputFile("input.txt");
    if (!inputFile.is_open()) {
        std::cerr << "Unable to open the file." << std::endl;
        return 1;
    }

    std::string line;
    while (std::getline(inputFile, line)) {
        std::cout << line << std::endl;
    }

    inputFile.close();
    return 0;
}

Output:

Unable to open the file.

This program reads each line from a file called “input.txt” and prints them to the standard output.

3. Using a Custom Delimiter

By default, getline uses the newline character \n as the delimiter to identify the end of a line. You can also provide a custom delimiter character to the function.

#include <iostream>
#include <string>

int main() {
    std::string input;
    std::getline(std::cin, input, ';');  // Read until semicolon delimiter
    std::cout << "You entered: " << input << std::endl;
    return 0;
}

Output:

You entered : Developerhelps

In this example, the program will read input until it encounters a semicolon ; character.

Advantages of using getline Function in C++

The getline function in C++ offers clear benefits:

Reads Full Lines: It captures entire lines of text, spaces and all, in a single go.
Handles Spaces: Unlike other methods, it handles spaces within input effortlessly.
Text Files: It’s perfect for processing text files, making reading and analyzing data easy.
Avoids Overflow: It dodges buffer overflow issues, ensuring safe and reliable input.
Flexible Inputs: It adapts to different input sources, accommodating various data streams.
Simplifies Coding: By swiftly reading lines, it simplifies your code and reduces complexity.

Disadvantages of getline function in C++

The getline function in C++ has a few drawbacks. It can be slower than using cin for reading individual values. Additionally, if not used carefully, it might lead to buffer overflow issues. Despite these limitations, with proper handling, the getline function remains a powerful tool for reading lines of text with spaces in C++ programs.

Conclusion

In short, the getline function in C++ holds remarkable power in reading an entire line of text, spaces included, into either a character array or a std::string. This function proves invaluable for managing text files or inputs laden with spaces. As you employ the getline function in C++, remember to weigh its pros and cons. It shines in its flexibility to manage various input streams and its skill to sidestep buffer overflow problems. However, it may operate slower than cin when reading single values. Mastered adeptly, the std::getline function in C++ becomes a tool to streamline input handling in your C++ programs.