[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","layouts/app-shell",{"_328":-5,"_9":10},"routes/subjects.$subject.topics.$topic",{"_9":10,"_11":12,"_13":14,"_15":16},"guest",true,"subjectTitle","C++ Fundamentals","topicTitle","Input, Output and Strings","questions",[17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],{"_33":310,"_35":311,"_37":312,"_38":63,"_39":313,"_41":314,"_43":315},{"_33":292,"_35":293,"_37":294,"_38":63,"_39":295,"_41":296,"_43":297},{"_33":274,"_35":275,"_37":276,"_38":63,"_39":277,"_41":278,"_43":279},{"_33":257,"_35":258,"_37":-5,"_38":-5,"_39":259,"_41":260,"_43":261},{"_33":239,"_35":240,"_37":241,"_38":63,"_39":242,"_41":243,"_43":244},{"_33":221,"_35":222,"_37":223,"_38":63,"_39":224,"_41":225,"_43":226},{"_33":203,"_35":204,"_37":205,"_38":63,"_39":206,"_41":207,"_43":208},{"_33":185,"_35":186,"_37":187,"_38":63,"_39":188,"_41":189,"_43":190},{"_33":167,"_35":168,"_37":169,"_38":63,"_39":170,"_41":171,"_43":172},{"_33":150,"_35":151,"_37":-5,"_38":-5,"_39":152,"_41":153,"_43":154},{"_33":132,"_35":133,"_37":134,"_38":63,"_39":135,"_41":136,"_43":137},{"_33":114,"_35":115,"_37":116,"_38":63,"_39":117,"_41":118,"_43":119},{"_33":97,"_35":98,"_37":-5,"_38":-5,"_39":99,"_41":100,"_43":101},{"_33":79,"_35":80,"_37":81,"_38":63,"_39":82,"_41":83,"_43":84},{"_33":60,"_35":61,"_37":62,"_38":63,"_39":64,"_41":65,"_43":66},{"_33":34,"_35":36,"_37":-5,"_38":-5,"_39":40,"_41":42,"_43":44},"id","cmuo4yxf900sn20jxjlpoqhjj","stem","Given std::string s = \"cat\";, which expression is a correct way to add \"s\" to the end to make \"cats\"?","codeBlock","codeLang","notes","## Concatenation\n\nUse `+` to join strings, or `+=` to add to the end. At least one side of `+` must be a `std::string` (not two C-string literals).\n\n```cpp\nstd::string first = \"Ada\", last = \"Lovelace\";\nstd::string name = first + \" \" + last; // \"Ada Lovelace\"\nname += \"!\"; // \"Ada Lovelace!\"\n```\n\nFor `std::string s = \"cat\";`, appending `\"s\"` with `s += \"s\"` (or the same thing as `s = s + \"s\"`) gives `\"cats\"`.\n\n**Gotcha:** `\"foo\" + \"bar\"` does **not** compile: you cannot add two `const char*`. Make one of them a `std::string`.","explanation","The += sign adds to the end of a std::string in place, giving cats. C++ has no '.' join sign. append takes what you add as an argument (s.append(\"s\")). << is for streams, not for joining strings.","options",[45,46,47,48],{"_33":58,"_50":59,"_37":-5,"_52":55},{"_33":56,"_50":57,"_37":-5,"_52":55},{"_33":53,"_50":54,"_37":-5,"_52":55},{"_33":49,"_50":51,"_37":-5,"_52":10},"cmuo4yxfg00sr20jxw6ze59pm","text","s += \"s\";","isCorrect","cmuo4yxfe00sq20jx002skqcx","s << \"s\";",false,"cmuo4yxfc00sp20jxhmnxa9ww","s.append() = \"s\";","cmuo4yxfa00so20jxtkcmbf4x","s = s . \"s\";","cmuo4yxez00si20jx8x19m7kv","The input holds: 5\\nhello world\\n (a number, a new line, then a line of text). With this code that has no loop, what does line end up as, and why is it a common bug?","int count;\nstd::string line;\nstd::cin >> count;\nstd::getline(std::cin, line);","cpp","## The leftover-newline trap (mixing `>>` and `getline`)\n\nThis is the classic bug. `>>` stops at a space but **leaves the newline in the buffer**. The next `getline` then reads that empty leftover and returns at once, so it looks like it \"skipped\" your input.\n\n```cpp\nint count;\nstd::string line;\nstd::cin >> count; // input is 5\\nhello world\\n; '\\n' stays in buffer\nstd::getline(std::cin, line); // reads the leftover '\\n' -> line is EMPTY!\n```\n\nGiven the input `5\\nhello world\\n`, `std::cin >> count` reads `5` but leaves the trailing `'\\n'` sitting in the buffer. The following `std::getline` immediately grabs that leftover `'\\n'`, so `line` ends up empty instead of `\"hello world\"` — a common, quiet bug from mixing `>>` and `getline`.\n\n**Fix:** throw away the rest of the line after `>>`, before you call `getline` (e.g. `std::cin.ignore(std::numeric_limits::max(), '\\n');`).","cin >> count stops just before the new line after 5. getline then reads up to that new line right away and returns empty text. Unlike >>, getline does NOT skip spaces at the start. Throw away the new line with cin.ignore before calling getline.",[67,68,69,70],{"_33":77,"_50":78,"_37":-5,"_52":55},{"_33":75,"_50":76,"_37":-5,"_52":10},{"_33":73,"_50":74,"_37":-5,"_52":55},{"_33":71,"_50":72,"_37":-5,"_52":55},"cmuo4yxf700sm20jxmcpkq37b","line is hello world, because getline skips spaces at the start like >>.","cmuo4yxf600sl20jx5r3l2hcy","line is hello, because getline stops at the first space.","cmuo4yxf400sk20jxphd2w39q","line is empty, because getline reads the new line left behind by >> before hello world.","cmuo4yxf200sj20jx9396iqrv","line is 5, because getline reads the number again.","cmuo4yxec00sd20jx0pmw9olo","What happens when this runs?","std::string s = \"hello\";\nint n = std::stoi(s);","## String to number: `std::stoi`, `std::stod`\n\n### What happens on bad input\n\n- **No digits at all** (e.g. `std::stoi(\"hello\")`): throws `std::invalid_argument`.\n\n```cpp\nstd::string s = \"hello\";\nint n = std::stoi(s); // throws std::invalid_argument\n```\n\nUnlike `>>`, these **throw exceptions** instead of setting a fail flag, so wrap them in a try/catch when the input is untrusted:\n\n```cpp\ntry {\n return std::stoi(s);\n} catch (const std::invalid_argument&) {\n return 0; // not a number\n}\n```","When stoi cannot read any characters (no digits at the start after any spaces or sign), it throws std::invalid_argument. It never quietly returns 0 or -1, so you must catch it or check for bad input first.",[85,86,87,88],{"_33":95,"_50":96,"_37":-5,"_52":55},{"_33":93,"_50":94,"_37":-5,"_52":55},{"_33":91,"_50":92,"_37":-5,"_52":55},{"_33":89,"_50":90,"_37":-5,"_52":10},"cmuo4yxej00sh20jxhwvzwu5c","It throws std::invalid_argument because no digits could be read.","cmuo4yxeh00sg20jxfxfo4cdu","n is set to 0.","cmuo4yxeg00sf20jx3q6u8o37","It fails to compile.","cmuo4yxee00se20jxj9jm8484","n is set to -1 as an error marker.","cmuo4yxc000s820jx31a8dnoj","Which call correctly throws away the leftover new line, so the getline after it reads a real line following a number read?","## The leftover-newline trap (mixing `>>` and `getline`)\n\n**Fix:** throw away the rest of the line after `>>`, before you call `getline`.\n\n```cpp\n#include \n\nstd::cin >> n;\nstd::cin.ignore(std::numeric_limits::max(), '\\n');\nstd::getline(std::cin, line); // now reads the intended line\n```\n\n- `ignore(count, delim)` throws away up to `count` characters, or stops early once it finds `delim`. The `numeric_limits` max just means \"as many as it takes.\"\n- Rule of thumb: once you mix `>>` reads and `getline` reads, put the `ignore` in between.","ignore(count, delim) throws away characters up to and including the new line. clear() only resets error flags. flush() is for output. reset() is not part of std::cin.",[102,103,104,105],{"_33":112,"_50":113,"_37":-5,"_52":55},{"_33":110,"_50":111,"_37":-5,"_52":10},{"_33":108,"_50":109,"_37":-5,"_52":55},{"_33":106,"_50":107,"_37":-5,"_52":55},"cmuo4yxc700sc20jxt3it11xz","std::cin.reset();","cmuo4yxc500sb20jxdx9r5opb","std::cin.flush();","cmuo4yxc400sa20jx5gp1jjig","std::cin.ignore(std::numeric_limits::max(), '\\n');","cmuo4yxc200s920jxmuw4ur4h","std::cin.clear();","cmuo4yxbr00s320jxm1hocemc","The user types Alice at the prompt. Why does the program never wait for the second input, and print an empty name?","int age;\nstd::string name;\nstd::cout << \"Age: \";\nstd::cin >> age;\nstd::cout << \"Name: \";\nstd::getline(std::cin, name);\nstd::cout << \"[\" << name << \"]\";","## The leftover-newline trap (mixing `>>` and `getline`)\n\nThis is the classic bug. `>>` stops at a space but **leaves the newline in the buffer**. The next `getline` then reads that empty leftover and returns at once, so it looks like it \"skipped\" your input.\n\n```cpp\nint age;\nstd::string name;\nstd::cin >> age; // user types Alice...\nstd::getline(std::cin, name); // reads the leftover '\\n' -> name is EMPTY!\n```\n\nHere, `std::cin >> age` reads a token and leaves the trailing `'\\n'` sitting in the input buffer. The very next `std::getline` immediately grabs that leftover `'\\n'` as if it were a (blank) line, so `name` ends up empty instead of waiting for real input.",">> stops at the new line after the number but does not remove it. The next getline hits that '\\n' first and stops at once, giving an empty line. Fix it by putting std::cin.ignore(std::numeric_limits::max(), '\\n') between the two reads.",[120,121,122,123],{"_33":130,"_50":131,"_37":-5,"_52":55},{"_33":128,"_50":129,"_37":-5,"_52":55},{"_33":126,"_50":127,"_37":-5,"_52":10},{"_33":124,"_50":125,"_37":-5,"_52":55},"cmuo4yxby00s720jxgwhh9alc","cin >> age eats the whole rest of the line, including the name.","cmuo4yxbw00s620jxlb4ujp95","cin >> age leaves the '\\n' behind in the input; getline reads that leftover new line right away and returns an empty string.","cmuo4yxbv00s520jx9yhkf699","std::string variables cannot be filled by getline after an int was read.","cmuo4yxbt00s420jx1ci8wmvr","getline can only be called once per program.","cmuo4yxbg00ry20jx0dvbr862","The input is one line: John Smith. What does line hold after this code runs?","std::string line;\nstd::getline(std::cin, line);","## Reading a line: `std::getline` vs `>>`\n\n- **`>>`** reads one word (stops at a space).\n- **`std::getline(std::cin, str)`** reads everything up to the next newline (and eats that newline), spaces and all. Use it for whole lines like \"New York\".\n\n```cpp\nstd::string line;\nstd::getline(std::cin, line);\n```\n\nGiven the input line `John Smith`, `line` ends up holding the whole line, spaces and all: `\"John Smith\"`.","std::getline reads everything up to the next new line, spaces and all, and throws away the new line itself (it is not kept). So line is exactly John Smith.",[138,139,140,141],{"_33":148,"_50":149,"_37":-5,"_52":55},{"_33":146,"_50":147,"_37":-5,"_52":55},{"_33":144,"_50":145,"_37":-5,"_52":55},{"_33":142,"_50":143,"_37":-5,"_52":10},"cmuo4yxbp00s220jxnnp7vobd","John Smith","cmuo4yxbn00s120jx2ml5qhjj","John","cmuo4yxbl00s020jxo4b8qutk","John Smith\\n (with the new line at the end kept)","cmuo4yxbk00rz20jxnhlb6wbf","Smith","cmuo4yxas00rt20jxz4xfya1x","Which statement about std::endl versus '\\n' is right?","## `std::endl` vs `'\\n'`\n\nBoth end a line. The difference is flushing (pushing the output out right away).\n\n- **`'\\n'`** writes a newline character. That is all.\n- **`std::endl`** writes a newline **and flushes the buffer** (forces the output out now).\n\nFlushing is slower. Use `'\\n'` in loops. Save `std::endl` for when you really need the output to show up now (say, a prompt right before a slow step).\n\n```cpp\nfor (int i = 0; i < 1000; ++i)\n std::cout << i << '\\n'; // fast, no per-line flush\nstd::cout << \"done\" << std::endl; // flush once at the end\n```\n\n**Gotcha:** `std::endl` in a tight loop is a common, quiet speed drain.","std::endl prints '\\n' and then pushes the waiting text out right away. '\\n' only prints the new-line character. So '\\n' is usually faster in loops, because it skips that forced push.",[155,156,157,158],{"_33":165,"_50":166,"_37":-5,"_52":55},{"_33":163,"_50":164,"_37":-5,"_52":10},{"_33":161,"_50":162,"_37":-5,"_52":55},{"_33":159,"_50":160,"_37":-5,"_52":55},"cmuo4yxb000rx20jx16dw6cmg","'\\n' pushes the waiting text out; std::endl does not.","cmuo4yxay00rw20jxf7ayx61z","std::endl writes two new lines; '\\n' writes one.","cmuo4yxaw00rv20jxzyboph6s","std::endl writes a new line AND pushes the waiting text out; '\\n' only writes a new line.","cmuo4yxau00ru20jxadkuwpxu","std::endl and '\\n' are the same in every way.","cmtym3xo000dgb1jxo9xjkkse","What is d after this line?","std::string s = \"3.14xyz\";\ndouble d = std::stod(s);","## String to number: `std::stoi`, `std::stod`\n\n- **`std::stod(s)`** gives back a `double`.\n\nThey skip spaces at the front, read as far as a valid number goes, then stop.\n\n```cpp\nstd::string s = \"3.14xyz\";\ndouble d = std::stod(s); // 3.14 (stops at 'x')\n```\n\n**Gotcha:** `std::stod(\"3.14xyz\")` works and returns `3.14` (it does not throw). If you need the whole string to be a valid number, check that the optional `pos` output equals `s.size()`.","std::stod reads the longest number it can from the front, here 3.14, then stops at the first character it cannot use ('x'). Text at the end does not cause a throw, as long as a valid number came first.",[173,174,175,176],{"_33":183,"_50":184,"_37":-5,"_52":55},{"_33":181,"_50":182,"_37":-5,"_52":55},{"_33":179,"_50":180,"_37":-5,"_52":55},{"_33":177,"_50":178,"_37":-5,"_52":10},"cmtym3xod00dkb1jx8vukjqws","3.14 — stod reads the number at the front and stops at 'x'.","cmtym3xoa00djb1jxgn3g3lpt","3.0 — stod ignores everything after the decimal point.","cmtym3xo700dib1jxultl04qk","0.0 — the mixed content makes the string bad.","cmtym3xo300dhb1jxqh0ed71v","It throws because of the xyz at the end.","cmtym3xn200d6b1jxcaek5art","What is n after this code?","std::string s = \" 123abc\";\nint n = std::stoi(s);","## String to number: `std::stoi`, `std::stod`\n\nFrom ``. Turn text into numbers:\n\n- **`std::stoi(s)`** gives back an `int`.\n\nThey skip spaces at the front, read as far as a valid number goes, then stop.\n\n```cpp\nstd::string s = \" 123abc\";\nint n = std::stoi(s); // 123 (skips the leading spaces, stops at 'a')\n```\n\n**Gotcha:** leftover junk after the number is just ignored, not an error — `std::stoi` works fine and returns the parsed number.","std::stoi skips spaces at the start, reads as many characters as make a valid whole number, and stops at the first one that does not (here 'a'). It returns 123 and does not throw just because there is junk at the end.",[191,192,193,194],{"_33":201,"_50":202,"_37":-5,"_52":55},{"_33":199,"_50":200,"_37":-5,"_52":55},{"_33":197,"_50":198,"_37":-5,"_52":55},{"_33":195,"_50":196,"_37":-5,"_52":10},"cmtym3xnh00dab1jx1r2vf883","123 — stoi skips spaces at the start and stops at the first character that is not a digit.","cmtym3xnf00d9b1jx9jfyd0zv","123 only if you first strip the spaces, otherwise it throws.","cmtym3xnb00d8b1jxtolxnnos","The call throws std::invalid_argument because of the abc at the end.","cmtym3xn600d7b1jxdwv8oh3z","0 — the letters at the end make the whole string bad.","cmtym3xmj00d1b1jx3b2e4l23","What does this print?","std::string a = \"apple\";\nstd::string b = \"banana\";\nstd::cout << (a < b);","## Comparison\n\n`std::string` works with `==`, `!=`, `<`, `>`, and so on directly. Order is **lexicographic** (dictionary order) by character code, which is **case-sensitive** ('Z' < 'a' in ASCII).\n\n```cpp\nstd::string a = \"apple\", b = \"banana\";\nstd::cout << (a < b); // true: 'a' < 'b', prints 1\n```\n\n**Gotcha:** do not use `strcmp`, and do not compare a `std::string` to a C-string with `==` hoping for pointer tricks; `==` on `std::string` compares the contents.","std::string compares one character at a time in dictionary order. 'a' (97) is less than 'b' (98), so a < b is true. Printing a true/false value shows 1, not the word true, unless std::boolalpha is turned on.",[209,210,211,212],{"_33":219,"_50":220,"_37":-5,"_52":55},{"_33":217,"_50":218,"_37":-5,"_52":10},{"_33":215,"_50":216,"_37":-5,"_52":55},{"_33":213,"_50":214,"_37":-5,"_52":55},"cmtym3xmx00d5b1jxbm5ivhs7","true","cmtym3xmt00d4b1jxr1m2szl4","It fails to compile; std::string has no < operator.","cmtym3xmr00d3b1jxs1u7gzsn","1","cmtym3xmn00d2b1jx52his6e1","0","cmtym3xm300cwb1jxa013fhs3","What does sub hold?","std::string s = \"abcdef\";\nstd::string sub = s.substr(2, 3);","## `.substr()`\n\n`s.substr(pos, len)` returns a copy that starts at `pos` and runs up to `len` characters (fewer if the string ends first). Leave out `len` to take the rest.\n\n```cpp\nstd::string s = \"abcdef\";\nstd::string sub = s.substr(2, 3); // starts at index 2 ('c'), takes 3 chars -> \"cde\"\n```\n\n**Gotcha:** if `pos > s.size()`, `substr` throws `std::out_of_range`. A `len` past the end is fine (it just stops at the end).","substr(pos, count) starts at spot pos and takes count characters. Starting at spot 2 ('c') and taking 3 gives cde. The second number is how many characters to take, not where to stop.",[227,228,229,230],{"_33":237,"_50":238,"_37":-5,"_52":55},{"_33":235,"_50":236,"_37":-5,"_52":10},{"_33":233,"_50":234,"_37":-5,"_52":55},{"_33":231,"_50":232,"_37":-5,"_52":55},"cmtym3xmg00d0b1jxu1koq3so","cd","cmtym3xmd00czb1jxiwt8hf1z","bcd","cmtym3xm900cyb1jxiv0wx5s8","cde","cmtym3xm600cxb1jxrm9459pt","cdef","cmtym3xla00crb1jx8zmo6v29","What is printed?","std::string s = \"world\";\nstd::cout << s[0] << s[s.length() - 1];","## Indexing and size\n\n- `s[i]` gets the character at index `i` (counting from 0). It does **not** check bounds; a bad index is **undefined behaviour** (anything can happen).\n- `.length()`/`.size()` give the character count.\n\n```cpp\nstd::string s = \"world\";\nchar first = s[0]; // 'w'\nchar last = s[s.length() - 1]; // 'd'\n```\n\nSo `std::cout << s[0] << s[s.length() - 1];` prints `wd`.\n\n**Gotcha:** `.size()` is **unsigned** (never negative). Writing `s.size() - 1` on an empty string wraps around to a huge number instead of `-1`. Guard it with `if (!s.empty())` before you subtract.","Counting starts at 0, so s[0] is 'w'. The last real spot is length()-1 == 4, which is 'd'. So it prints wd.",[245,246,247,248],{"_33":255,"_50":256,"_37":-5,"_52":10},{"_33":253,"_50":254,"_37":-5,"_52":55},{"_33":251,"_50":252,"_37":-5,"_52":55},{"_33":249,"_50":250,"_37":-5,"_52":55},"cmtym3xm100cvb1jx09iwfga5","wo","cmtym3xls00cub1jx8ldbws43","we","cmtym3xlk00ctb1jx9x3v1qqe","w followed by the end marker","cmtym3xld00csb1jx6dbk7y1a","wd","cmtym3xkw00cmb1jxeipi0mv8","For std::string s = \"hello\";, what does s.length() return, and how does it relate to s.size()?","## Indexing and size\n\n- `.length()` and `.size()` are the same: both give the character count as an unsigned number.\n\n```cpp\nstd::string s = \"hello\";\nstd::size_t n = s.size(); // 5 (same as s.length())\n```\n\nSo for `std::string s = \"hello\";`, `s.length()` returns `5`, and it always matches `s.size()` — they're just two names for the same thing.","length() and size() mean the exact same thing and return the number of characters, not counting any hidden end marker. \"hello\" has 5 characters, so both return 5.",[262,263,264,265],{"_33":272,"_50":273,"_37":-5,"_52":10},{"_33":270,"_50":271,"_37":-5,"_52":55},{"_33":268,"_50":269,"_37":-5,"_52":55},{"_33":266,"_50":267,"_37":-5,"_52":55},"cmtym3xl800cqb1jxdsuoxm8d","4; counting starts at 0, so the count is one less than the number of characters.","cmtym3xl500cpb1jxngxqoyan","5 for length() but 6 for size(), because size() counts the end marker.","cmtym3xl200cob1jxubc3etjl","6; the count includes an end marker character.","cmtym3xkz00cnb1jxm78js7ib","5; length() and size() are the same and both return 5.","cmtym3xk700chb1jxx9qb2p5d","What does result contain?","std::string first = \"foo\";\nstd::string second = \"bar\";\nstd::string result = first + second + \"!\";","## Concatenation\n\nUse `+` to join strings, or `+=` to add to the end. At least one side of `+` must be a `std::string` (not two C-string literals).\n\n```cpp\nstd::string first = \"foo\";\nstd::string second = \"bar\";\nstd::string result = first + second + \"!\"; // \"foobar!\"\n```\n\nEach `+` joins the pieces in order, so `result` ends up as `\"foobar!\"`.","The + sign on a std::string joins the pieces with nothing added between them, and you may join a std::string with a plain C text literal. The pieces become foobar!.",[280,281,282,283],{"_33":290,"_50":291,"_37":-5,"_52":55},{"_33":288,"_50":289,"_37":-5,"_52":10},{"_33":286,"_50":287,"_37":-5,"_52":55},{"_33":284,"_50":285,"_37":-5,"_52":55},"cmtym3xkt00clb1jxprtx2sll","foo bar !","cmtym3xkq00ckb1jxznrh74qo","foo+bar+!","cmtym3xkn00cjb1jxvrnl9u5d","foobar!","cmtym3xkk00cib1jxfjxm04t2","A compile error, because you cannot add a text literal to a std::string.","cmtym3xia00bxb1jxn9zg6wtj","The user types 42 5 and presses Enter. What are the values of a and b?","int a, b;\nstd::cin >> a >> b;","## `std::cout` and `std::cin` basics\n\n`std::cin` reads from standard input. The stream operator is `>>` for input (\"get from\"). It hands back the stream, so you can chain many reads in one statement.\n\n```cpp\nint a, b;\nstd::cin >> a >> b;\n```\n\n- `>>` skips spaces at the front, then reads until the next space. So each `>>` reads one word — typing `42 5` puts `42` into `a` and `5` into `b`.",">> skips spaces at the start and stops at the next space. So it reads 42 into a and 5 into b. Chaining >> signs reads each value one at a time.",[298,299,300,301],{"_33":308,"_50":309,"_37":-5,"_52":10},{"_33":306,"_50":307,"_37":-5,"_52":55},{"_33":304,"_50":305,"_37":-5,"_52":55},{"_33":302,"_50":303,"_37":-5,"_52":55},"cmtym3xip00c1b1jxg5c68w5k","a == 4, b == 2","cmtym3xil00c0b1jxmsl64k9x","a == 425, b is never given a value","cmtym3xii00bzb1jx1nbewr1c","a == 42, b is never given a value","cmtym3xif00byb1jxf6g3p0re","a == 42, b == 5","cmtym3xh600bnb1jxtljpv1xx","What does this program print?","#include \nint main() {\n std::cout << \"a\" << \"b\" << \"c\";\n}","## `std::cout` and `std::cin` basics\n\n`std::cout` (from ``) writes to standard output. The stream operator is `<<` for output (\"put to\"). It hands back the stream, so you can chain many values in one statement.\n\n```cpp\nstd::cout << \"a\" << \"b\" << \"c\";\n```\n\nEach `<<` prints its argument and hands back `std::cout`, so the next `<<` works on the same stream — the pieces just get printed one after another with nothing in between.","When you chain many << signs in a row, each value prints one after another, left to right. No spaces are added. No new lines are added. So \"a\", \"b\", and \"c\" print right next to each other as abc.",[316,317,318,319],{"_33":326,"_50":327,"_37":-5,"_52":10},{"_33":324,"_50":325,"_37":-5,"_52":55},{"_33":322,"_50":323,"_37":-5,"_52":55},{"_33":320,"_50":321,"_37":-5,"_52":55},"cmtym3xhm00brb1jxcbufnchh","a b c","cmtym3xhi00bqb1jxf9rblh5k","a, then b, then c on separate lines","cmtym3xhe00bpb1jxtz96bcqo","cba","cmtym3xha00bob1jxaaz7q9co","abc","email"]