C++ Input Doesn't Have to Be Complicated: Word and Line Input using EasyIn

Gregor — Fri, 11 Sep 2026 15:07:15 +0000

Getting input in C++ is simple until you start mixing different types of input.

You might want to read:

an integer,
one word,
a full name with spaces,
or input from a file instead of the console.

Then suddenly you're dealing with std::cin, std::getline(), leftover newlines, failed stream states, and cleanup code.

That's why I made EasyIn, a small header-only C++ input helper.

GitHub: https://github.com/gregorskof/EasyIn

Two functions

EasyIn keeps the API intentionally small:

easyin::input(...)
easyin::inputln(...)

The main difference is simple:

input() reads one value or one word.

inputln() reads a whole line.

For example:

#include <iostream>
#include <string>
#include "easyin.hpp"

int main() {
    std::string word;
    std::string line;

    std::cout << "Enter one word: ";
    easyin::input(word);

    std::cout << "Enter a full line: ";
    easyin::inputln(line);

    std::cout << "Word: " << word << '\n';
    std::cout << "Line: " << line << '\n';
}

If the user enters:

Hello world

input() reads:

Hello

because it uses stream extraction with >>.

inputln() reads the whole line:

Hello world

Reading other types

input() isn't only for strings.

You can use it with normal stream-extractable types:

int age{};
double price{};

easyin::input(age);
easyin::input(price);

So instead of writing:

std::cin >> age;

you can write:

easyin::input(age);

The important difference is that EasyIn also reports whether the read succeeded.

Input now returns `bool`

Both functions return true when the read succeeds and false when it fails.

int age{};

std::cout << "Enter your age: ";

if (!easyin::input(age)) {
    std::cout << "Invalid input.\n";
    return 1;
}

This is especially useful for numeric input.

If the user enters something that can't be read as an integer, you can detect the problem instead of continuing with invalid data.

Automatic cleanup after failed input

A failed std::cin extraction normally puts the stream into a failed state.

That means simply trying to read again isn't enough.

EasyIn attempts to recover by clearing the stream state and discarding the rest of the failed line:

in.clear();
in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

So a retry loop can stay relatively small:

int age{};

for (;;) {
    std::cout << "Enter your age: ";

    if (easyin::input(age)) {
        break;
    }

    if (!std::cin.good()) {
        std::cout << "Input stream ended.\n";
        return 1;
    }

    std::cout << "Please enter a valid integer.\n";
}

EasyIn doesn't try to replace application-level validation.

For example:

-20

is still a perfectly valid integer as far as the input function is concerned.

If negative ages aren't allowed, that check belongs in your program.

`input()` vs `inputln()`

This is probably the most important distinction in the library.

`input()`

inline bool input(auto &var, std::istream &in = std::cin);

It uses:

in >> var

For strings, that means reading until whitespace.

Input:

Hello world

First call:

Hello

Second call:

world

This is useful for things like:

username
command
number
menu option

`inputln()`

inline bool inputln(std::string &var, std::istream &in = std::cin);

It uses std::getline() together with std::ws.

That lets it read strings containing spaces:

std::string name;

std::cout << "Full name: ";
easyin::inputln(name);

Input:

John Smith

Result:

John Smith

Using std::ws also makes inputln() convenient after numeric input because it skips leftover whitespace and newlines.

There is one trade-off: because leading whitespace is skipped, inputln() isn't intended for cases where blank lines or indentation must be preserved exactly.

For that, use std::getline() directly.

Mixing numbers and lines

One of the common C++ beginner problems looks like this:

int age;
std::string name;

std::cin >> age;
std::getline(std::cin, name);

The getline() may immediately consume the newline left behind by the previous extraction.

With EasyIn:

int age{};
std::string name;

easyin::input(age);
easyin::inputln(name);

inputln() handles the whitespace before reading the line.

A complete version:

#include <iostream>
#include <string>
#include "easyin.hpp"

int main() {
    int age{};
    std::string name;

    std::cout << "Age: ";
    if (!easyin::input(age)) {
        std::cerr << "Could not read age.\n";
        return 1;
    }

    std::cout << "Name: ";
    if (!easyin::inputln(name)) {
        std::cerr << "Could not read name.\n";
        return 1;
    }

    std::cout << "Hello, " << name
              << "! You are " << age
              << " years old.\n";
}

Input doesn't have to come from `std::cin`

Both functions take an optional std::istream.

That means the same functions can work with other streams.

For example:

#include <sstream>
#include "easyin.hpp"

int main() {
    std::istringstream source("25\n");

    int age{};

    if (!easyin::input(age, source)) {
        return 1;
    }
}

You can also use file streams.

#include <fstream>
#include <iostream>
#include "easyin.hpp"

int main() {
    std::ifstream file("numbers.txt");

    int number{};

    while (easyin::input(number, file)) {
        std::cout << number << '\n';
    }
}

And for lines:

std::string line;

while (easyin::inputln(line, file)) {
    std::cout << line << '\n';
}

So EasyIn isn't really tied to console input.

It works with C++ input streams in general.

It's still header-only

The library is contained in:

easyin.hpp

Just put it in your project:

#include "easyin.hpp"

The functions are declared inline, so the header can be included from multiple .cpp files without creating multiple-definition linker errors.

EasyIn currently requires C++20 or newer because input() uses an abbreviated function template:

inline bool input(auto &var, std::istream &in = std::cin);

The library itself doesn't require C++23.

You can use normal std::cout, or combine it with C++23's std::print() / std::println() if your compiler supports them.

The goal

EasyIn isn't meant to replace everything you can do with C++ streams.

It's intentionally tiny.

The idea is simply to make common input code easier to read:

easyin::input(value);

for one value or word, and:

easyin::inputln(line);

for a full line.

Both tell you whether the read succeeded, both support other input streams, and both attempt to recover after malformed input.

If you're learning C++, or just want a very small wrapper around the most common input operations, that's what EasyIn is for.

The project is open source under the MIT License:

GitHub: EasyIn
Video introduction on YouTube

Feedback and contributions are welcome.

DEV Community: Gregor

C++ Input Doesn't Have to Be Complicated: Word and Line Input using EasyIn

Two functions

Reading other types

Input now returns bool

Automatic cleanup after failed input

input() vs inputln()

input()

inputln()

Mixing numbers and lines

Input doesn't have to come from std::cin

It's still header-only

The goal

Input now returns `bool`

`input()` vs `inputln()`

`input()`

`inputln()`

Input doesn't have to come from `std::cin`