[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","layouts/app-shell",{"_255":-5,"_9":10},"routes/subjects.$subject.topics.$topic",{"_9":10,"_11":12,"_13":14,"_15":16},"guest",true,"subjectTitle","C for Beginners","topicTitle","Input, Output, Files and Memory","questions",[17,18,19,20,21,22,23,24,25,26,27,28],{"_29":237,"_31":238,"_33":239,"_35":36,"_37":240,"_39":241,"_41":242},{"_29":219,"_31":220,"_33":221,"_35":36,"_37":222,"_39":223,"_41":224},{"_29":201,"_31":202,"_33":203,"_35":36,"_37":204,"_39":205,"_41":206},{"_29":183,"_31":184,"_33":185,"_35":36,"_37":186,"_39":187,"_41":188},{"_29":165,"_31":166,"_33":167,"_35":36,"_37":168,"_39":169,"_41":170},{"_29":147,"_31":148,"_33":149,"_35":36,"_37":150,"_39":151,"_41":152},{"_29":129,"_31":130,"_33":131,"_35":36,"_37":132,"_39":133,"_41":134},{"_29":112,"_31":113,"_33":114,"_35":36,"_37":115,"_39":116,"_41":117},{"_29":94,"_31":95,"_33":96,"_35":36,"_37":97,"_39":98,"_41":99},{"_29":76,"_31":77,"_33":78,"_35":36,"_37":79,"_39":80,"_41":81},{"_29":58,"_31":59,"_33":60,"_35":36,"_37":61,"_39":62,"_41":63},{"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":40,"_41":42},"id","cmuo4yvkf00au20jx8t5ysq7c","stem","The code below frees the memory that p points to, then reads through p right after. What is wrong with this?","codeBlock","#include \n#include \n\nint main(void) {\n int *p = malloc(sizeof(int));\n *p = 5;\n free(p);\n printf(\"%d\\n\", *p);\n return 0;\n}","codeLang","c","notes","### Common memory bugs — Use-after-free\n\n**Use-after-free:** using a pointer to read or write memory after you've already called `free(p)` on it. That memory may now be used for something else — this is unpredictable and can cause serious bugs.\n\n```c\nfree(p);\np = NULL; /* good habit: avoids accidental use-after-free */\n```","explanation","free(p) tells the memory manager that the block p points to can now be reused. After that call, p is called a 'dangling pointer' — using it to read or write, as *p does here, is undefined behaviour, because that memory may already be reused for something else. This kind of bug is called 'use after free.' A related bug is calling free(p) a second time on the same pointer, which is also undefined behaviour. Forgetting to call free at all, on the other hand, causes a memory leak, not a crash.","options",[43,44,45,46],{"_29":56,"_48":57,"_33":-5,"_50":10},{"_29":54,"_48":55,"_33":-5,"_50":51},{"_29":52,"_48":53,"_33":-5,"_50":51},{"_29":47,"_48":49,"_33":-5,"_50":51},"cmuo4yvkm00ay20jxi4d5e44c","text","There is no problem; free only marks memory as available for later reuse, so *p still safely holds 5.","isCorrect",false,"cmuo4yvkl00ax20jxmie6o919","This causes a memory leak because the memory was freed too soon.","cmuo4yvkj00aw20jxytxbl7ze","The real bug is that p was never set to NULL after malloc, not the free call itself.","cmuo4yvkh00av20jxgvxindq9","This is a 'use-after-free' bug: once free(p) runs, the program no longer owns that memory, and reading *p afterward is undefined behaviour — it may print garbage, damage other data, or crash.","cmuo4yvk600ap20jx9r875nbt","The code below reserves memory with malloc for 5 whole numbers and right away prints the first slot, without ever storing a value in it. What does it print?","#include \n#include \n\nint main(void) {\n int *arr = malloc(5 * sizeof(int));\n printf(\"%d\\n\", arr[0]);\n free(arr);\n return 0;\n}","### malloc\n\n```c\nint *p = malloc(n * sizeof(int));\nif (p == NULL) {\n fprintf(stderr, \"out of memory\\n\");\n exit(1);\n}\n```\n\n- Gives you a pointer to `n` bytes of memory. The contents are unpredictable (not set to anything specific). Gives back `NULL` if it can't find enough memory.\n- **Watch out:** the memory holds leftover junk — don't assume it starts at zero.\n- **Always check for `NULL`** before you use the pointer.","malloc reserves a block of memory but does not clear it, so the bits inside are whatever was left over from earlier use — basically random leftover data. Reading arr[0] before storing anything in it gives an unpredictable value; the exact number depends on the computer and cannot be known ahead of time. If you need memory that starts out as zero, use calloc instead, which does clear it.",[64,65,66,67],{"_29":74,"_48":75,"_33":-5,"_50":51},{"_29":72,"_48":73,"_33":-5,"_50":51},{"_29":70,"_48":71,"_33":-5,"_50":10},{"_29":68,"_48":69,"_33":-5,"_50":51},"cmuo4yvkd00at20jxx38hlkmv","5","cmuo4yvkc00as20jxhkcbjh4j","Its value cannot be predicted (undefined behaviour): malloc does not clear the memory it gives back, so arr[0] holds whatever leftover bits were already there.","cmuo4yvka00ar20jx2mmsdg7z","The program always crashes at this line.","cmuo4yvk800aq20jx17qqwe7w","0","cmuo4yvju00ak20jx2eegggey","The code below reads a line of text into a small storage space using gets. Why is this a serious bug, and what should be used instead?","#include \n\nint main(void) {\n char buf[10];\n gets(buf);\n printf(\"%s\", buf);\n return 0;\n}","## Never use `gets`\n\n**Never use `gets`** — it has no way to stop itself once the buffer is full, so it can write past the end of the buffer (this is called a buffer overflow). Use `fgets` instead.\n\n```c\nchar line[100];\nwhile (fgets(line, sizeof(line), fp) != NULL) {\n printf(\"%s\", line);\n}\n```\n\n`fgets`:\n- **Keeps the newline** `\\n` at the end of the line, if there's room.\n- **Stops after `size - 1` characters** even if the line is longer, so it doesn't overflow the buffer, and always adds a `\\0` at the end.","gets reads a whole line with no limit on how many characters it writes, because it is never told how big the destination space is. Any input longer than that space overflows it, overwriting nearby memory — a well-known security bug, which is why gets was removed from the C language rules entirely. fgets fixes this by being told the size of the space up front, for example fgets(buf, sizeof(buf), stdin), and stopping before it overflows. Note: fgets also keeps the newline character in the text if there was room for it.",[82,83,84,85],{"_29":92,"_48":93,"_33":-5,"_50":51},{"_29":90,"_48":91,"_33":-5,"_50":10},{"_29":88,"_48":89,"_33":-5,"_50":51},{"_29":86,"_48":87,"_33":-5,"_50":51},"cmuo4yvk300ao20jx7257ftke","gets is only risky when reading numbers, not plain text.","cmuo4yvk000an20jxo00sv081","gets is safe here because buf holds exactly 10 characters, matching typical short inputs.","cmuo4yvjz00am20jx1yr88z3w","gets has no way of knowing how big the storage space is, so if the user types more than 9 characters, it writes past the end of buf and corrupts nearby memory. It should be replaced with fgets(buf, sizeof(buf), stdin), which stops once it reaches the given size.","cmuo4yvjw00al20jxj5wt03p9","gets is fine as long as buf is created as a pointer instead of an array.","cmuo4yvjl00af20jxmmjwiqa2","The code below opens a file named 'data.txt' for reading, then reads a line from it. If the file does not exist, what is the bug?","#include \n\nint main(void) {\n FILE *fp = fopen(\"data.txt\", \"r\");\n char line[100];\n fgets(line, sizeof(line), fp);\n printf(\"%s\", line);\n fclose(fp);\n return 0;\n}","## File Access — Opening\n\n```c\nFILE *fp = fopen(name, \"r\");\nif (fp == NULL) {\n fprintf(stderr, \"cannot open %s\\n\", name);\n exit(1);\n}\n```\n\n**Always check for `NULL`** — `fopen` fails if the file doesn't exist, can't be created, or you don't have permission.","fopen gives back NULL when it cannot open the file, for example because the file does not exist. Good code always checks this: if (fp == NULL) { show an error and stop }. This code skips that check, so if the file is missing, fp is NULL, and calling fgets(line, sizeof(line), fp) with a NULL file value is undefined behaviour, usually a crash. Note: mode \"w\" opens a file for writing and erases anything already in it, so switching to \"w\" would not fix a reading problem and would actually make things worse here.",[100,101,102,103],{"_29":110,"_48":111,"_33":-5,"_50":10},{"_29":108,"_48":109,"_33":-5,"_50":51},{"_29":106,"_48":107,"_33":-5,"_50":51},{"_29":104,"_48":105,"_33":-5,"_50":51},"cmuo4yvjs00aj20jx173ilbst","fgets will just give back an empty piece of text if the file is missing, so the code is safe.","cmuo4yvjq00ai20jxklpt72eg","fopen automatically creates the file if it is missing, so there is no bug.","cmuo4yvjp00ah20jxyw4fr0k2","The code should use mode \"w\" instead of \"r\" to avoid the problem.","cmuo4yvjn00ag20jxlkx1fcl0","The code never checks whether fopen gave back NULL. If 'data.txt' does not exist, fopen gives back NULL, and passing that NULL value to fgets is undefined behaviour, which usually crashes the program.","cmuo4yvj900aa20jxswj19sre","Suppose the user runs the code below and types '5 x' then presses Enter. What number does printf print?","#include \n\nint main(void) {\n int a, b, n;\n n = scanf(\"%d %d\", &a, &b);\n printf(\"%d\\n\", n);\n return 0;\n}","## scanf — Return Value\n\n`scanf` gives back the **number of values it read successfully** (or `EOF` if input ran out or failed). Always check this number to catch bad input.\n\n```c\nint n;\nif (scanf(\"%d\", &n) != 1) {\n fprintf(stderr, \"bad input\\n\");\n exit(1);\n}\n```","scanf gives back the count of values it successfully read, not the count of characters it looked at. It reads '5' just fine and stores it in a, but then it expects another whole number and finds 'x' instead, which cannot be read as a number, so it stops and gives back 1. b is never set. scanf only gives back EOF (a negative value) if it fails to read anything at all before running out of input.",[118,119,120,121],{"_29":128,"_48":75,"_33":-5,"_50":51},{"_29":126,"_48":127,"_33":-5,"_50":10},{"_29":124,"_48":125,"_33":-5,"_50":51},{"_29":122,"_48":123,"_33":-5,"_50":51},"cmuo4yvjj00ae20jxbn6t6fhb","-1","cmuo4yvjh00ad20jxiyrhblgp","2","cmuo4yvjf00ac20jx7yg1ab5o","1","cmuo4yvjd00ab20jxjv03o3em","cmuo4yviy00a520jxr3jz3div","A program creates 'char name[20];' to hold a word typed by the user. Which line correctly reads a word into name using scanf?","#include \n\nint main(void) {\n char name[20];\n /* which line goes here? */\n return 0;\n}","## scanf — Reading strings\n\n**Exception:** when reading a string with `%s` into a `char` array, the array name already stands for its address, so you don't add `&`:\n\n```c\nchar name[50];\nscanf(\"%s\", name); // no & here\n```","An array's name, like name, already stands for the address of its first slot, so scanf(\"%s\", name) passes the correct address. Adding & (as in &name) gives the address of the whole array, which is a different type than expected and not correct for %s, even though it might seem to work — it is technically undefined behaviour. This is the one case where %s does not need &: single numbers and single characters need &, but a char array used with %s does not.",[135,136,137,138],{"_29":145,"_48":146,"_33":-5,"_50":51},{"_29":143,"_48":144,"_33":-5,"_50":51},{"_29":141,"_48":142,"_33":-5,"_50":10},{"_29":139,"_48":140,"_33":-5,"_50":51},"cmuo4yvj600a920jx2dw4tcl9","scanf(\"%s\", &name);","cmuo4yvj300a820jxy6grxz96","scanf(\"%s\", name);","cmuo4yvj200a720jx1nx666n0","scanf(\"&s\", name);","cmuo4yvj000a620jx5s5oq2rz","scanf(\"%s\", *name);","cmuo4yvia00a020jx4lwpbhe5","The code below reads a line of text typed by the user and passes it straight into printf as the format text. Suppose the user types text with a percent sign followed by a letter, like '%d'. What is most likely to go wrong with this code?","#include \n\nint main(void) {\n char s[100];\n fgets(s, sizeof(s), stdin);\n printf(s);\n return 0;\n}","### Danger: `printf(s)` with user input\n\nIf `s` is text typed by the user, calling `printf(s)` treats that text as the **format string** (the instructions for what to print). If the text has `%` characters in it, `printf` will try to read extra values that don't exist. This can cause the program to behave in an unpredictable way, crash, or open a security hole.\n\n```c\n/* WRONG: user-controlled format string */\nprintf(s);\n\n/* RIGHT: s is just data, not a format */\nprintf(\"%s\", s);\n```","printf's first input is treated as format text: any % it finds is read as the start of a special instruction, and printf then looks for an extra value to fill it in. If the user's own text contains a %, like '%d', printf will search for a value that was never given, producing garbage output or crashing. The safe way to print text of unknown content is printf(\"%s\", s), which always prints s exactly as it is, no matter what it contains. Also note: fgets keeps the newline character in the text if there is room for it — it does not remove it.",[153,154,155,156],{"_29":163,"_48":164,"_33":-5,"_50":51},{"_29":161,"_48":162,"_33":-5,"_50":51},{"_29":159,"_48":160,"_33":-5,"_50":51},{"_29":157,"_48":158,"_33":-5,"_50":10},"cmuo4yvik00a420jxprxm78eq","printf will treat the % parts in the user's text as instructions to print extra values, and will try to read values that were never given to it. This causes undefined behaviour — garbage output or a crash. The code should instead be written as printf(\"%s\", s).","cmuo4yvii00a320jxguzruyma","The code fails to compile because printf's first input must be fixed text written directly in the code, not a variable.","cmuo4yvie00a220jxfawp0ghi","fgets removes the newline character, so printf(s) is safe as long as the text is short.","cmuo4yvid00a120jx7q4gibq2","Nothing is wrong; printf always prints its text exactly as given when no extra values are passed.","cmuo4yvi2009v20jxd6g86po6","The code below prints the number 10 in base 16 (hexadecimal), right away followed by a plain percent sign. What does it print?","#include \n\nint main(void) {\n printf(\"%x%%\\n\", 10);\n return 0;\n}","## printf Conversions — %x and %%\n\n| Conversion | Meaning |\n|---|---|\n| `%x` | a number shown as hexadecimal, no sign |\n| `%%` | a plain `%` character |\n\n**Watch out:** To print a plain `%`, you must type `%%`. A single `%` on its own is read as the start of something to fill in.\n\n```c\nprintf(\"100%%\\n\"); // \"100%\"\n```","%x prints a number in base 16 with no extra prefix, and 10 in base 16 is 'a'. To print a plain percent sign, you write %% in the format text, because a single % tells printf that a special value is coming next. So the output is 'a%'. If you wanted the '0x' prefix shown too, you would need to add it yourself or use %#x.",[171,172,173,174],{"_29":181,"_48":182,"_33":-5,"_50":10},{"_29":179,"_48":180,"_33":-5,"_50":51},{"_29":177,"_48":178,"_33":-5,"_50":51},{"_29":175,"_48":176,"_33":-5,"_50":51},"cmuo4yvi9009z20jxgn05fzrz","10%","cmuo4yvi7009y20jx7o2bkjxa","0xa%","cmuo4yvi5009x20jxwkzop5tq","a%%","cmuo4yvi4009w20jxj45tn1r9","a%","cmuo4yvhr009q20jxwabtwrne","The code below prints a decimal number, showing exactly 2 digits after the decimal point. What does it print?","#include \n\nint main(void) {\n printf(\"%.2f\\n\", 3.14159);\n return 0;\n}","## printf Conversions — Precision\n\n`.n` after the width sets the **precision**: the longest a string can be for `%s`, or how many digits come after the decimal point for `%f`.\n\n```c\nprintf(\"%.2f\\n\", 3.14159); // \"3.14\"\n```","The .2 in %.2f tells printf to show exactly 2 digits after the decimal point, rounding the number if needed. 3.14159 rounded to 2 decimal places is 3.14.",[189,190,191,192],{"_29":199,"_48":200,"_33":-5,"_50":51},{"_29":197,"_48":198,"_33":-5,"_50":51},{"_29":195,"_48":196,"_33":-5,"_50":10},{"_29":193,"_48":194,"_33":-5,"_50":51},"cmuo4yvi0009u20jxb9oxls96","3.1","cmuo4yvhy009t20jxxjst6u35","3.14","cmuo4yvhx009s20jxb1913jet","3.142","cmuo4yvhu009r20jxf59oh3mp","3.14159","cmuo4yvhh009l20jx1047riw0","Look at the code below. It uses printf to print a whole number in a space that is 5 characters wide, inside square brackets. What does it print?","#include \n\nint main(void) {\n printf(\"[%5d]\\n\", 42);\n return 0;\n}","## printf Conversions — Width\n\nA number placed before the conversion sets the smallest **width** (it fills empty space with spaces). Normally the text lines up on the right.\n\n```c\nprintf(\"%5d\\n\", 42); // \" 42\"\n```","%5d means: print the number in a space that is at least 5 characters wide. Numbers are lined up on the right by default, so spaces are added before the digits. Since 42 has 2 digits, 3 spaces are added, giving ' 42'. To line the number up on the left instead, you would add a minus sign, like %-5d. To fill the empty space with zeros instead of spaces, you would use %05d.",[207,208,209,210],{"_29":217,"_48":218,"_33":-5,"_50":51},{"_29":215,"_48":216,"_33":-5,"_50":10},{"_29":213,"_48":214,"_33":-5,"_50":51},{"_29":211,"_48":212,"_33":-5,"_50":51},"cmuo4yvhp009p20jx4mpy2ass","[00042]","cmuo4yvhn009o20jxolwi2yhs","[42]","cmuo4yvhl009n20jxnh0edrjb","[ 42]","cmuo4yvhk009m20jxep5y5lnd","[42 ]","cmumydhu200dh3ijxbob7enp6","The code below writes an error message and stops the program when a file cannot be opened. Why does it write to stderr instead of using printf, and what does exit(1) do?","#include \n#include \n\nint main(void) {\n FILE *fp = fopen(\"missing.txt\", \"r\");\n if (fp == NULL) {\n fprintf(stderr, \"cannot open file\\n\");\n exit(1);\n }\n fclose(fp);\n return 0;\n}","## Errors and exit\n\nWhen something goes wrong (a file won't open, bad input, memory couldn't be allocated), write a message to `stderr` and stop the program:\n\n```c\nif (fp == NULL) {\n fprintf(stderr, \"%s: cannot open file\\n\", progname);\n exit(1);\n}\n```\n\n`exit(1)` (any number other than 0) tells whoever ran the program that it failed; `exit(0)` means it succeeded. Keeping error messages on `stderr` means a program's normal output can be redirected elsewhere without losing the error text.","C programs have three standard channels: stdin (input), stdout (normal output), and stderr (error output). They are kept separate, so if a user redirects stdout into a file (for example, by running the program with '> out.txt'), messages sent to stderr still show up on the screen instead of being hidden inside that file. Calling exit(1) (or exit(EXIT_FAILURE)) stops the program right away and reports a nonzero result, which by convention means 'something went wrong,' letting other scripts or programs detect the failure.",[225,226,227,228],{"_29":235,"_48":236,"_33":-5,"_50":51},{"_29":233,"_48":234,"_33":-5,"_50":10},{"_29":231,"_48":232,"_33":-5,"_50":51},{"_29":229,"_48":230,"_33":-5,"_50":51},"cmumydhuc00dl3ijxsggohj1v","exit(1) pauses the program for 1 second before continuing.","cmumydhua00dk3ijxvkhdvvia","stderr is just another name for stdout, so fprintf(stderr, ...) behaves exactly like printf.","cmumydhu800dj3ijxu3bp5dra","stderr is a separate output channel meant just for error messages, so they still show up even if the program's normal output (stdout) is being redirected into a file. exit(1) immediately ends the program and reports a nonzero result to whatever started it, signalling that something went wrong.","cmumydhu700di3ijxczi1oi6c","fprintf(stderr, ...) holds its output back until the program ends normally, unlike printf.","cmumydhri00ci3ijx0gtj4bgf","Look at the scanf call in the code below. What is wrong with it?","#include \n\nint main(void) {\n int n;\n printf(\"Enter a number: \");\n scanf(\"%d\", n);\n printf(\"You entered %d\\n\", n);\n return 0;\n}","## scanf\n\n`scanf` reads input and needs the **address** (memory location) of each variable so it knows where to store the value:\n\n```c\nint n;\nscanf(\"%d\", &n);\n```\n\n**Watch out:** If you forget `&` before a plain variable (like `scanf(\"%d\", n)`), you give `scanf` the *value* instead of the *address*. `scanf` then writes to some random memory spot — this is unpredictable and often crashes the program.","scanf stores the value it reads into the memory location you give it, so for a plain variable you must give its address using &, for example &n. Passing n by itself passes whatever leftover value is already sitting in that variable (which was never set), and scanf treats that leftover number as a memory address to write into — this is undefined behaviour and often causes a crash.",[243,244,245,246],{"_29":253,"_48":254,"_33":-5,"_50":51},{"_29":251,"_48":252,"_33":-5,"_50":51},{"_29":249,"_48":250,"_33":-5,"_50":10},{"_29":247,"_48":248,"_33":-5,"_50":51},"cmumydhrx00cm3ijxqzv94rst","n must be given a starting value of 0 before calling scanf.","cmumydhru00cl3ijxwall5xye","scanf needs the memory address of the variable to store the value into, so it should be &n. Passing n on its own (a variable with no starting value) makes scanf write to a random memory location, which is undefined behaviour and often crashes the program.","cmumydhrr00ck3ijx0vls7nnq","scanf should use %i instead of %d to read whole numbers.","cmumydhrp00cj3ijx5hxbwivo","The format text should be \"%d\\n\" to match the newline the user types.","email"]