{"title":"Input & Output (cin, cout, cerr)","description":null,"content":"Every C++ program eventually needs to talk to the outside world: print a result, read a value the user typed, or report something that went wrong. The standard library handles all of this through stream objects defined in ``. This lesson covers the four common streams, the operators that drive them, line-based input, formatting, and the bugs that come up often.\n\n---\n\n# The Four Standard Streams\n\nIncluding `` gives you four objects in the `std` namespace, each tied to a different communication channel:\n\n\n| Stream | Direction | Channel | Buffered? | Use for |\n|--------|-----------|---------|-----------|---------|\n| `std::cin` | Input | Standard input (stdin) | Yes | Reading from the keyboard or piped input |\n| `std::cout` | Output | Standard output (stdout) | Yes | Normal program output |\n| `std::cerr` | Output | Standard error (stderr) | No (unbuffered) | Error messages, urgent diagnostics |\n| `std::clog` | Output | Standard error (stderr) | Yes | Logging, non-urgent diagnostics |\n\n\n`cerr` and `clog` both write to the same destination (stderr), but they behave differently. `cerr` is unbuffered, meaning every character is pushed out immediately. `clog` buffers its output the same way `cout` does, so writes are batched until the buffer fills or an explicit flush happens. The distinction matters and is covered below.\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Welcome to the AlgoMaster Store!\" << std::endl;\n std::cerr << \"DEBUG: store opened at 09:00\" << std::endl;\n std::clog << \"INFO: home page loaded\" << std::endl;\n return 0;\n}\n```\n\n\nIn a normal terminal, all three lines show up in the same window because stdout and stderr are both connected to the screen. The difference becomes visible after redirecting one of them, which is the point of having separate streams.\n\nRunning the program above as `./store > out.txt` sends only the first line into `out.txt`. The two stderr lines still print to the terminal. That separation lets shell scripts and CI systems keep error logs apart from normal output.\n\n---\n\n# Output with `std::cout` and `<<`\n\n`std::cout` is the standard output stream. Values get pushed into it with the `<<` operator, called the **stream insertion operator** when used with a stream on the left. `std::cout << x` reads as \"push `x` into the cout stream.\"\n\nThe operator returns the stream itself, which is what makes chaining possible:\n\n\n```cpp\n#include \n\nint main() {\n std::string product = \"Wireless Mouse\";\n int quantity = 3;\n double price = 24.99;\n\n std::cout << \"Product: \" << product << std::endl;\n std::cout << \"Quantity: \" << quantity << \", Price: $\" << price << std::endl;\n std::cout << \"Subtotal: $\" << quantity * price << std::endl;\n return 0;\n}\n```\n\n\nA single statement like `std::cout << \"Quantity: \" << quantity << \", Price: $\" << price` is four chained calls. Each `<<` writes the value on its right and returns the stream so the next `<<` has something to write into. That's why one line can mix strings, integers, and doubles without any explicit formatting calls.\n\nAny built-in type and most standard-library types (`std::string`, for example) work directly with `cout`. For a custom class, `<<` has to be defined, which is what the Operator Overloading section covers.\n\n---\n\n# `std::endl` vs `'\\n'`\n\nBoth `std::endl` and the character `'\\n'` move the cursor to the next line. The difference is what else they do.\n\n- `std::endl` writes a newline **and** flushes the stream's buffer. Flushing forces any pending output to be written out immediately.\n- `'\\n'` (or `\"\\n\"` inside a string) writes a newline and nothing else. The buffer keeps holding whatever it had.\n\nFor one-line programs, the difference is invisible. The buffer gets flushed when the program exits anyway. The difference matters in tight loops.\n\n\n```cpp\n#include \n\nint main() {\n // Tight loop: prefer '\\n' to avoid flushing 10,000 times.\n for (int i = 1; i <= 10000; ++i) {\n std::cout << \"Order #\" << i << '\\n';\n }\n std::cout << std::flush; // flush once at the end if you need to\n return 0;\n}\n```\n\n\nWriting `std::endl` inside the loop would call flush 10,000 times. Each flush goes through a system call to the operating system, which is much more expensive than appending bytes to an in-memory buffer.\n\n`std::endl` flushes the output buffer on every call. In hot loops that print thousands of lines, replace it with `'\\n'` and flush once at the end, or rely on automatic flushing at program exit.\n\nThe rule of thumb: use `'\\n'` by default, use `std::endl` only when the output needs to appear immediately (for example, when prompting the user and waiting for a response).\n\n---\n\n# Input with `std::cin` and `>>`\n\n`std::cin` reads from standard input. Values come out with `>>`, the **stream extraction operator**. `std::cin >> x` reads as \"pull a value out of cin and store it in `x`.\"\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string product;\n int quantity;\n double price;\n\n std::cout << \"Product name: \";\n std::cin >> product;\n\n std::cout << \"Quantity: \";\n std::cin >> quantity;\n\n std::cout << \"Unit price: \";\n std::cin >> price;\n\n std::cout << \"You ordered \" << quantity << \" x \" << product\n << \" at $\" << price << \" each.\" << std::endl;\n return 0;\n}\n```\n\n\n**Sample run (user input is the value after each prompt):**\n\n\n```shell\nProduct name: Mouse\nQuantity: 3\nUnit price: 24.99\nYou ordered 3 x Mouse at $24.99 each.\n```\n\n\n`>>` is token-based, which is the most important fact about it. Extracting into a variable makes `cin` skip leading whitespace (spaces, tabs, newlines), read characters until the next whitespace, and convert the result to the requested type. The whitespace that stopped the read stays in the buffer for the next operation.\n\nThat last detail is why `>>` cannot read `\"Wireless Mouse\"` into a `std::string`. The space between the words stops the extraction. Running the program above with `Wireless Mouse` as input would set `product` to `\"Wireless\"` and try to read `Mouse` as the quantity, which fails. `std::getline` fixes this, covered below.\n\nLike `<<`, the `>>` operator returns the stream, so extractions can be chained:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string product;\n int quantity;\n double price;\n\n std::cout << \"Enter product, quantity, price (one per line or space-separated): \";\n std::cin >> product >> quantity >> price;\n\n std::cout << product << \" x \" << quantity << \" @ $\" << price << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nEnter product, quantity, price (one per line or space-separated): Mouse 3 24.99\nMouse x 3 @ $24.99\n```\n\n\nWhitespace between tokens is treated the same whether it's a space or a newline. Three values on three separate lines work as well as three values on one line.\n\n---\n\n# Reading Whole Lines with `std::getline`\n\nFor input that might contain spaces (a customer name, a shipping address, a product description), `>>` won't do. The standard solution is `std::getline`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string customerName;\n std::string address;\n\n std::cout << \"Customer name: \";\n std::getline(std::cin, customerName);\n\n std::cout << \"Shipping address: \";\n std::getline(std::cin, address);\n\n std::cout << \"Shipping to \" << customerName << \" at \" << address << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nCustomer name: Priya Sharma\nShipping address: 221B Baker Street, London\nShipping to Priya Sharma at 221B Baker Street, London\n```\n\n\n`std::getline(std::cin, line)` reads everything up to and including the next newline. The newline itself is consumed (so the next read starts fresh) but is **not** stored in `line`. The whole rest of the input line, spaces and all, becomes part of the string.\n\nTwo arguments matter here: the stream to read from (`std::cin`) and the string to fill (`customerName`). A third optional argument changes the delimiter from newline to something else, but the two-argument form is the usual choice for keyboard input.\n\n---\n\n# The Classic `>>` Then `getline` Bug\n\nMixing `>>` and `std::getline` is the single most common C++ I/O mistake. The bug looks like this:\n\n**Broken code:**\n\n\n```cpp\n#include \n#include \n\nint main() {\n int quantity;\n std::string customerName;\n\n std::cout << \"Quantity: \";\n std::cin >> quantity;\n\n std::cout << \"Customer name: \";\n std::getline(std::cin, customerName);\n\n std::cout << \"Order: \" << quantity << \" items for [\" << customerName << \"]\" << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nQuantity: 3\nCustomer name: Order: 3 items for []\n```\n\n\nThe program never gives the user a chance to type the name. Here's why: `cin >> quantity` reads `3` and stops at the newline that the user pressed Enter to send. That newline stays in the input buffer. The next `std::getline` reads \"everything up to the next newline,\" which is right there in the buffer, so it returns an empty string immediately.\n\n**Fix:** drain the leftover newline before the `getline`. The cleanest tool is `std::cin.ignore(...)`.\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n int quantity;\n std::string customerName;\n\n std::cout << \"Quantity: \";\n std::cin >> quantity;\n std::cin.ignore(std::numeric_limits::max(), '\\n');\n\n std::cout << \"Customer name: \";\n std::getline(std::cin, customerName);\n\n std::cout << \"Order: \" << quantity << \" items for [\" << customerName << \"]\" << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nQuantity: 3\nCustomer name: Priya Sharma\nOrder: 3 items for [Priya Sharma]\n```\n\n\n`std::cin.ignore(n, c)` discards up to `n` characters or up to and including the first occurrence of character `c`, whichever comes first. Passing `std::numeric_limits::max()` for `n` (which lives in ``) means \"no upper limit,\" so the only stop condition is hitting the newline. After the ignore call, the buffer is fresh and `getline` does the right thing.\n\n---\n\n# Reading Different Types\n\nThe `>>` operator is overloaded for all the built-in types and `std::string`, so the same syntax works regardless of what's being read:\n\n\n```cpp\n#include \n#include \n\nint main() {\n int quantity;\n double price;\n char grade;\n std::string productCode;\n bool inStock;\n\n std::cout << \"Enter quantity price grade code stock(0/1): \";\n std::cin >> quantity >> price >> grade >> productCode >> inStock;\n\n std::cout << \"qty=\" << quantity\n << \" price=\" << price\n << \" grade=\" << grade\n << \" code=\" << productCode\n << \" inStock=\" << inStock << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nEnter quantity price grade code stock(0/1): 3 24.99 A MOUSE-001 1\nqty=3 price=24.99 grade=A code=MOUSE-001 inStock=1\n```\n\n\nOne thing to note about `char`: extracting a `char` reads a single non-whitespace character, not a single character including whitespace. To read a space or a tab, use `std::cin.get(ch)` instead, which reads the next character regardless.\n\nFor `bool`, the default text representation is `0` or `1`. Typing `true` and `false` instead requires the `std::boolalpha` manipulator, covered in the formatting section.\n\n---\n\n# Stream State: `good`, `fail`, `bad`, `eof`\n\nEvery stream tracks a small set of state flags that report whether the last operation went well. The four query methods cover the common cases:\n\n\n| Method | Returns true when |\n|--------|-------------------|\n| `cin.good()` | No error flags are set. The stream is healthy. |\n| `cin.fail()` | The last operation failed to extract a value (for example, asking for an `int` but the user typed `abc`). |\n| `cin.bad()` | A serious I/O error happened (rare; usually means the underlying device went wrong). |\n| `cin.eof()` | The stream reached end-of-file. No more input is coming. |\n\n\nThe stream can also be tested directly in an `if` or `while` condition. A stream evaluates to `true` when it's healthy and `false` when any error flag is set:\n\n\n```cpp\n#include \n\nint main() {\n int quantity;\n std::cout << \"Quantity: \";\n\n if (std::cin >> quantity) {\n std::cout << \"You ordered \" << quantity << \" items.\" << std::endl;\n } else {\n std::cerr << \"ERROR: that doesn't look like a whole number.\" << std::endl;\n }\n return 0;\n}\n```\n\n\n**Sample run with valid input:**\n\n\n```shell\nQuantity: 5\nYou ordered 5 items.\n```\n\n\n**Sample run with invalid input:**\n\n\n```shell\nQuantity: abc\nERROR: that doesn't look like a whole number.\n```\n\n\nThe expression `std::cin >> quantity` returns the stream, which converts to a boolean for the `if` check. When the extraction fails, the stream's `failbit` is set, the boolean conversion gives `false`, and the `else` branch runs.\n\n---\n\n# Recovering from Bad Input\n\nOnce a stream is in a failed state, every subsequent operation does nothing until the error is cleared. Two calls work together to recover:\n\n1. `std::cin.clear()` resets the error flags so the stream is usable again.\n2. `std::cin.ignore(std::numeric_limits::max(), '\\n')` throws away the offending input that caused the failure.\n\nBoth are needed. `clear()` alone leaves the bad characters in the buffer, so the next read fails the same way. `ignore()` alone runs into the failed state and does nothing.\n\n\n```cpp\n#include \n#include \n\nint main() {\n int quantity = 0;\n\n while (true) {\n std::cout << \"Quantity (positive integer): \";\n if (std::cin >> quantity && quantity > 0) {\n break;\n }\n std::cerr << \"Invalid input. Please enter a positive whole number.\" << std::endl;\n std::cin.clear();\n std::cin.ignore(std::numeric_limits::max(), '\\n');\n }\n\n std::cout << \"You ordered \" << quantity << \" items.\" << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nQuantity (positive integer): abc\nInvalid input. Please enter a positive whole number.\nQuantity (positive integer): -2\nInvalid input. Please enter a positive whole number.\nQuantity (positive integer): 5\nYou ordered 5 items.\n```\n\n\nThis pattern (prompt, read, validate, clear-and-ignore on failure, retry) makes a reliable interactive prompt in C++. The diagram below walks through it:\n\n\n```mermaid\nflowchart LR\n A[Prompt user]:::cyan --> B[cin >> value]:::orange\n B --> C{Stream
good?}:::orange\n C -->|Yes| D{Value
valid?}:::orange\n D -->|Yes| E[Use value]:::green\n D -->|No| F[Report error]:::red\n C -->|No| F\n F --> G[cin.clear
cin.ignore]:::teal\n G --> A\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\n`clear()` resets the flags, `ignore(...)` discards the leftover garbage, and the loop tries again. Without that cleanup, the program would spin printing the error forever because the same bad characters would re-trigger the failure on every iteration.\n\n---\n\n# Writing Errors with `std::cerr` and `std::clog`\n\nBoth `cerr` and `clog` write to stderr, the same channel used by error messages. The split between them comes down to buffering.\n\n`std::cerr` is unbuffered. Every write goes out to the OS immediately. That's the right choice for a fatal error: even if the program crashes in the next microsecond, the error message has already been written.\n\n`std::clog` is buffered like `std::cout`. Writes accumulate in memory and flush when the buffer fills or on an explicit flush. That's better for high-volume logging where each individual message isn't urgent, because the buffered version avoids the cost of a system call per write.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string product = \"Wireless Mouse\";\n int requested = 5;\n int available = 0;\n\n std::cout << \"Order received for \" << requested << \" x \" << product << std::endl;\n\n if (requested > available) {\n std::cerr << \"WARNING: \" << product << \" is out of stock (requested \"\n << requested << \", available \" << available << \")\" << std::endl;\n return 1;\n }\n\n std::clog << \"INFO: order fulfilled for \" << product << std::endl;\n return 0;\n}\n```\n\n\n**Output (to terminal, with stderr and stdout interleaved):**\n\n\n```shell\nOrder received for 5 x Wireless Mouse\nWARNING: Wireless Mouse is out of stock (requested 5, available 0)\n```\n\n\nRunning this program as `./order > orders.log 2> errors.log` puts the `Order received` line in `orders.log` and the `WARNING` line in `errors.log`. The split shows up only when redirected.\n\nA useful rule: log warnings and unrecoverable errors to `cerr`, log routine diagnostic information to `clog`, and use `cout` for the actual output the program is supposed to produce. Returning a non-zero exit status (`return 1;`) is the matching convention for signaling failure to whatever script ran the program.\n\n---\n\n# Formatting with ``\n\nOut of the box, `cout` prints numbers with sensible defaults but no control over width, alignment, or precision. The `` header provides a set of **manipulators** that get inserted into the stream to change how the next values are formatted.\n\n\n| Manipulator | What it does |\n|-------------|--------------|\n| `std::setw(n)` | Sets the minimum field width for the **next** value to `n` characters. |\n| `std::setfill(c)` | Sets the character used to pad short values to the field width. Defaults to space. |\n| `std::left` / `std::right` | Left- or right-aligns values within their field. Default is right. |\n| `std::setprecision(n)` | Sets the number of digits used for floating-point output. |\n| `std::fixed` | Print floats in fixed-point notation. `setprecision` now means digits after the decimal. |\n| `std::scientific` | Print floats in scientific notation (e.g., `1.234e+02`). |\n| `std::defaultfloat` | Restore the default floating-point format. |\n| `std::boolalpha` / `std::noboolalpha` | Print `bool` as `true`/`false` or `1`/`0`. |\n| `std::hex`, `std::dec`, `std::oct` | Print integers in base 16, 10, or 8. |\n| `std::showpos` / `std::noshowpos` | Print a leading `+` for positive numbers, or not. |\n\n\nMost manipulators are **sticky**: they keep their setting until changed. The one exception is `std::setw`, which resets to zero after the very next value is written. That's the right behavior for column layouts.\n\n### A Formatted Receipt\n\nLining up columns is the primary use case for these manipulators. A printed receipt that mirrors what a real store would output:\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::cout << std::fixed << std::setprecision(2);\n\n std::cout << std::left << std::setw(20) << \"Item\"\n << std::right << std::setw(5) << \"Qty\"\n << std::setw(10) << \"Price\"\n << std::setw(10) << \"Total\" << '\\n';\n\n std::cout << std::left << std::setw(20) << \"Wireless Mouse\"\n << std::right << std::setw(5) << 3\n << std::setw(10) << 24.99\n << std::setw(10) << 74.97 << '\\n';\n\n std::cout << std::left << std::setw(20) << \"USB-C Cable\"\n << std::right << std::setw(5) << 2\n << std::setw(10) << 9.99\n << std::setw(10) << 19.98 << '\\n';\n\n std::cout << std::left << std::setw(20) << \"Mousepad\"\n << std::right << std::setw(5) << 1\n << std::setw(10) << 6.50\n << std::setw(10) << 6.50 << '\\n';\n\n std::cout << std::string(45, '-') << '\\n';\n std::cout << std::left << std::setw(20) << \"Total\"\n << std::right << std::setw(25) << 101.45 << '\\n';\n return 0;\n}\n```\n\n\nA few things are happening here. `std::fixed` switches floats into fixed-point mode so the output has exactly two digits after the decimal. `std::setprecision(2)` sets how many of those digits. Both are sticky, so setting them once at the top makes every subsequent float follow. `std::setw(20)` applied right before `\"Wireless Mouse\"` reserves a 20-character field, and `std::left` left-aligns the name inside it. `std::right` then aligns the numeric columns to the right edge of their fields.\n\n### Boolean and Numeric Base Manipulators\n\n`boolalpha` and the base manipulators are smaller features but show up often enough to mention:\n\n\n```cpp\n#include \n#include \n\nint main() {\n bool inStock = true;\n\n std::cout << \"Default: \" << inStock << '\\n';\n std::cout << std::boolalpha << \"With boolalpha: \" << inStock << '\\n';\n std::cout << std::noboolalpha << \"Reset: \" << inStock << '\\n';\n\n int productId = 255;\n std::cout << \"Decimal: \" << productId << '\\n';\n std::cout << \"Hex: \" << std::hex << productId << '\\n';\n std::cout << \"Octal: \" << std::oct << productId << '\\n';\n std::cout << \"Back to decimal: \" << std::dec << productId << '\\n';\n return 0;\n}\n```\n\n\n`boolalpha` is handy for printing a human-readable status. `hex`, `dec`, and `oct` come up in low-level work (memory addresses, bit patterns), but decimal is the common case. Like other formatting manipulators, all four are sticky, so switch back when done.\n\n---\n\n# `std::flush` and Output Buffering\n\n`std::cout` and `std::clog` are line-buffered when connected to a terminal and block-buffered when connected to a file or pipe. That means output might sit in memory for a while before it reaches the screen or the disk. Three things force a flush:\n\n- The buffer fills up.\n- The stream is destroyed (at program exit, for example).\n- An explicit flush with `std::endl`, `std::flush`, or by reading from `cin` (which auto-flushes `cout` by default).\n\nThe last point is why prompts usually work without `endl`: a `std::cin >>` call flushes anything pending on `cout` first. Still, it's safer to write `std::flush` or `std::endl` after a prompt so the prompt appears before the program blocks waiting for input.\n\nEach flush is a system call. Writing `std::endl` inside a million-iteration loop spends most of its time talking to the OS instead of doing useful work. Use `'\\n'` for newlines and flush only when output ordering matters.\n\n---\n\n# A Quick Word on `using namespace std;`\n\nMany tutorials drop the `std::` prefix by writing `using namespace std;` at the top. That works, but it has real downsides in larger projects: it pulls every name from the standard library into the local scope, which can collide with custom names or names from other libraries.\n\nThis lesson keeps the explicit `std::` prefix for clarity. The Namespaces section covers the trade-offs in depth, including when `using namespace std;` is acceptable, when it's risky, and the safer alternatives (`using std::cout;`, scoped `using` inside a function, and so on).\n\n---\n\n# `sync_with_stdio` for Competitive Programming\n\nBy default, C++'s `cin`/`cout` stay synchronized with C's `printf`/`scanf` so they can be mixed freely in the same program. That synchronization costs performance. Without mixing C and C++ I/O, it can be turned off:\n\n\n```cpp\n#include \n\nint main() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n\n int n;\n std::cin >> n;\n std::cout << \"Read \" << n << \" items\\n\";\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\n1000000\nRead 1000000 items\n```\n\n\n`sync_with_stdio(false)` decouples C++ streams from C stdio buffers. `cin.tie(nullptr)` stops `cin` from flushing `cout` before each input operation. Combined, they often make `cin`/`cout` competitive with `scanf`/`printf` on large inputs.\n\nUse this only when the C and C++ I/O facilities won't be mixed. For everyday application code, leave the defaults alone. The speedup matters in tight read loops over millions of values, which is mostly a competitive programming concern.\n\n`printf` and `scanf` from `` are the C-style alternatives. They still work in C++, and they appear in older code or on competitive programming sites. This lesson doesn't cover them. The C Interoperability section in Advanced Topics has the details.\n\n---\n\n# A Complete E-Commerce Example\n\nTying everything together, a small program that takes a customer's information, builds a receipt, and writes a warning to `cerr` when stock is low:\n\n\n```cpp\n#include \n#include \n#include \n#include \n\nint main() {\n std::string customerName;\n std::string productName;\n int quantity;\n int stockAvailable = 4;\n double unitPrice;\n\n std::cout << \"Customer name: \";\n std::getline(std::cin, customerName);\n\n std::cout << \"Shipping address: \";\n std::string address;\n std::getline(std::cin, address);\n\n std::cout << \"Product name: \";\n std::getline(std::cin, productName);\n\n std::cout << \"Quantity: \";\n std::cin >> quantity;\n\n std::cout << \"Unit price: \";\n std::cin >> unitPrice;\n\n if (quantity > stockAvailable) {\n std::cerr << \"WARNING: only \" << stockAvailable << \" units of \"\n << productName << \" in stock. Order will be partial.\" << std::endl;\n quantity = stockAvailable;\n }\n\n double subtotal = quantity * unitPrice;\n double tax = subtotal * 0.08;\n double total = subtotal + tax;\n\n std::cout << '\\n' << std::string(45, '=') << '\\n';\n std::cout << \"AlgoMaster Store Receipt\\n\";\n std::cout << std::string(45, '=') << '\\n';\n std::cout << \"Customer: \" << customerName << '\\n';\n std::cout << \"Ship to: \" << address << \"\\n\\n\";\n\n std::cout << std::fixed << std::setprecision(2);\n std::cout << std::left << std::setw(25) << \"Item\"\n << std::right << std::setw(8) << \"Qty\"\n << std::setw(12) << \"Total\" << '\\n';\n std::cout << std::string(45, '-') << '\\n';\n std::cout << std::left << std::setw(25) << productName\n << std::right << std::setw(8) << quantity\n << std::setw(12) << subtotal << '\\n';\n std::cout << std::string(45, '-') << '\\n';\n std::cout << std::left << std::setw(33) << \"Tax (8%)\"\n << std::right << std::setw(12) << tax << '\\n';\n std::cout << std::left << std::setw(33) << \"Total\"\n << std::right << std::setw(12) << total << '\\n';\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nCustomer name: Priya Sharma\nShipping address: 221B Baker Street, London\nProduct name: Wireless Mouse\nQuantity: 6\nUnit price: 24.99\nWARNING: only 4 units of Wireless Mouse in stock. Order will be partial.\n\n=============================================\nAlgoMaster Store Receipt\n=============================================\nCustomer: Priya Sharma\nShip to: 221B Baker Street, London\n\nItem Qty Total\n---------------------------------------------\nWireless Mouse 4 99.96\n---------------------------------------------\nTax (8%) 8.00\nTotal 107.96\n```\n\n\nThis one program uses `getline` for the multi-word inputs, `>>` for the numeric inputs, `cerr` for the stock warning, `std::fixed` plus `std::setprecision` for two-decimal currency, and `std::setw` with `std::left`/`std::right` to line up the columns.","pageType":"cpp"}

Input & Output (cin, cout, cerr)

Get Premium