Tag: output

Most programs need to communicate: show results to a user and read values to decide what to do next. C++ provides two standard streams for console programs:

• std::cout — character output to the screen (think: print).
• std::cin — character input from the keyboard (think: read).

They’re part of the <iostream> library and give you a uniform way to send values out and bring values in. The same ideas later extend to files and other sources/destinations, so learning the console streams is a good, practical starting point.

We’ll return to the deeper details (buffering, formatting, error states, files, line-based input) in later posts. Here we’ll focus on the essentials you can use right away.

Printing with std::cout (output)

To write text or values to the console, insert them into std::cout using the << operator.

#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
    return 0;
}

• << means “send the thing on the right into the stream on the left.”
• You can chain multiple insertions in one statement:

#include <iostream>

int main() {
    int x = 7;
    int y = 5;
    std::cout << "x = " << x << ", y = " << y << "\n";
    return 0;
}

Newlines: '\n' vs std::endl

• '\n' prints a newline character.
• std::endl also prints a newline and forces a flush of the output buffer.
• For routine printing, prefer '\n' (simple and efficient). We’ll discuss flushing later.

Reading with std::cin (input)

To read values from the keyboard, extract them from std::cin using the >> operator.

#include <iostream>

int main() {
    int a;
    std::cout << "Enter an integer: ";
    std::cin >> a;

    std::cout << "You entered: " << a << "\n";
    return 0;
}

• >> means “take a value from the stream on the left and store it in the variable on the right.”
• std::cin automatically skips leading spaces and reads up to the next whitespace for numbers.
• You can read multiple values in one go:

#include <iostream>

int main() {
    int width, height;
    std::cout << "Enter width and height (two integers): ";
    std::cin >> width >> height;

    int area = width * height;
    std::cout << "Area = " << area << "\n";
    return 0;
}

You can type the two integers separated by spaces or on separate lines—std::cin handles both.

Note: If the user types something that isn’t a valid number, the input operation fails and std::cin enters a “failed” state. We’ll cover checking and recovering from input errors later.

Why streams are useful

• Uniform interface: the same << and >> style works with many types (integers, floating-point, and later strings, custom types, files).
• Composability: you can chain operations (cout << a << b << c; and cin >> x >> y;) to keep code compact.
• Extensibility: later, the same model applies to file I/O (std::ifstream, std::ofstream) and formatting controls (field width, precision, etc.).

Mini-reference (for now)

• Include header: #include <iostream>
• Write text/value: std::cout << "text" << value << '\n';
• Read value(s): std::cin >> variable; or std::cin >> v1 >> v2;
• Newline: prefer '\n' for simple line breaks

A small, self-contained example

#include <iostream>

int main() {
    int a, b;

    std::cout << "Enter two integers: ";
    std::cin >> a >> b;

    int sum = a + b;
    int product = a * b;

    std::cout << "Sum = " << sum << '\n';
    std::cout << "Product = " << product << '\n';

    return 0;
}

Type, press Enter, and the program echoes the results. That’s enough to start building interactive examples.

What we’ll cover later

There is a lot more to say about input and output streams. This will be covered in later, more advanced posts when we have learned a bit more about the standard library in C++. Here are some topics that I will get back to.

• Reading full lines of text and words (and how whitespace matters)
• Formatting numbers (precision, alignment)
• Handling input errors robustly
• File input/output using the same stream concepts
• Performance and buffering details

With std::cout and std::cin in your toolkit, you can already build simple interactive programs.