[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","layouts/app-shell",{"_355":-5,"_9":10},"routes/subjects.$subject.topics.$topic",{"_9":10,"_11":12,"_13":14,"_15":16},"guest",true,"subjectTitle","C++ Fundamentals","topicTitle","Pointers and References","questions",[17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],{"_35":338,"_37":252,"_39":339,"_40":133,"_41":340,"_43":341,"_45":342},{"_35":321,"_37":252,"_39":322,"_40":133,"_41":323,"_43":324,"_45":325},{"_35":304,"_37":305,"_39":-5,"_40":-5,"_41":306,"_43":307,"_45":308},{"_35":286,"_37":287,"_39":288,"_40":133,"_41":289,"_43":290,"_45":291},{"_35":269,"_37":252,"_39":270,"_40":133,"_41":271,"_43":272,"_45":273},{"_35":251,"_37":252,"_39":253,"_40":133,"_41":254,"_43":255,"_45":256},{"_35":235,"_37":236,"_39":-5,"_40":-5,"_41":237,"_43":238,"_45":239},{"_35":218,"_37":219,"_39":-5,"_40":-5,"_41":220,"_43":221,"_45":222},{"_35":201,"_37":202,"_39":-5,"_40":-5,"_41":203,"_43":204,"_45":205},{"_35":184,"_37":185,"_39":-5,"_40":-5,"_41":186,"_43":187,"_45":188},{"_35":167,"_37":168,"_39":-5,"_40":-5,"_41":169,"_43":170,"_45":171},{"_35":149,"_37":150,"_39":151,"_40":133,"_41":152,"_43":153,"_45":154},{"_35":130,"_37":131,"_39":132,"_40":133,"_41":134,"_43":135,"_45":136},{"_35":113,"_37":114,"_39":-5,"_40":-5,"_41":115,"_43":116,"_45":117},{"_35":96,"_37":97,"_39":-5,"_40":-5,"_41":98,"_43":99,"_45":100},{"_35":79,"_37":80,"_39":-5,"_40":-5,"_41":81,"_43":82,"_45":83},{"_35":62,"_37":63,"_39":-5,"_40":-5,"_41":64,"_43":65,"_45":66},{"_35":36,"_37":38,"_39":-5,"_40":-5,"_41":42,"_43":44,"_45":46},"id","cmuo4yxnw00uq20jxkj29rl7v","stem","For `double* p;` on a typical 64-bit computer, what does `sizeof(p)` measure?","codeBlock","codeLang","notes","A pointer is a variable that holds a memory address.\n\n```cpp\nint x = 42;\nint* p = &x; // p holds the address of x\n```\n\nA pointer has its own address, separate from the thing it points to (see the pointer/reference trait table: \"Has its own address: yes\"). Because a pointer just stores an address, `sizeof(p)` measures the size of that stored address (typically 8 bytes on a 64-bit system), no matter what type it points at. That's different from `sizeof(*p)`, the size of the pointed-to type, which decides how far pointer arithmetic moves (`p + 1` moves ahead by `sizeof(*p)`).","explanation","`p` is a pointer, so `sizeof(p)` is the space needed to hold an address (often 8 bytes on a 64-bit machine), no matter what type it points to. `sizeof(*p)` would be the size of a double. A pointer has no idea how many items sit at that address.","options",[47,48,49,50],{"_35":60,"_52":61,"_39":-5,"_54":55},{"_35":58,"_52":59,"_39":-5,"_54":10},{"_35":56,"_52":57,"_39":-5,"_54":55},{"_35":51,"_52":53,"_39":-5,"_54":55},"cmuo4yxo400uu20jxmtshvlyh","text","How many doubles p points to","isCorrect",false,"cmuo4yxo100ut20jxzlkuon1q","The size of a double, which is 8 bytes","cmuo4yxo000us20jxcq0o3180","The size of the pointer itself (often 8 bytes), not the size of a double","cmuo4yxny00ur20jxd12h2j3z","Always 4 bytes, because pointers are ints","cmuo4yxno00ul20jx0elh90ds","When would you pick a pointer parameter instead of a reference parameter?","Pick based on whether the argument might be missing, and whether the function has to point it at a different object.\n\n- **Reference parameter** (`T&`): use it when the object always exists and you just need to read or change it. Cleaner call site, can't be null.\n- **Pointer parameter** (`T*`): use it when the argument is optional (can be `nullptr`), or when the function must change *which* object the caller's variable points at.\n\n```cpp\nvoid maybe(int* p) { if (p) ++*p; } // optional argument\n\nmaybe(nullptr); // no-op, legal\n```","A reference must always point at a real object, so it cannot say 'nothing here'. A pointer can be `nullptr`, which makes it the right choice for an optional argument the function must check for. If the argument is required, a reference is usually clearer.",[67,68,69,70],{"_35":77,"_52":78,"_39":-5,"_54":55},{"_35":75,"_52":76,"_39":-5,"_54":55},{"_35":73,"_52":74,"_39":-5,"_54":55},{"_35":71,"_52":72,"_39":-5,"_54":10},"cmuo4yxnv00up20jx40xpytkt","When the argument is optional and 'no object' (nullptr) is a value that means something","cmuo4yxnt00uo20jx8lnj76nz","Always, because references are being taken out of the language","cmuo4yxns00un20jxeum6ceaz","When you want the function to be unable to change the argument","cmuo4yxnq00um20jx21chjji4","When the argument must never be empty (null)","cmuo4yxn500ug20jxu2j5ekm3","A function needs to make the caller's pointer point at a different object. What must the parameter be?","**When you must re-point:** to change where a caller's *pointer* points, take a pointer-to-pointer or a reference-to-pointer. A plain `T*` parameter is just a copy of the pointer; setting it to a new address inside the function does nothing to the caller.\n\n```cpp\nvoid reseat(int*& p, int* target) { p = target; } // reference to pointer\n\nint a = 1, b = 2;\nint* q = &a;\nreseat(q, &b); // now q points at b\n```","If you pass `int*`, the function gets a copy of the pointer, so changing the copy does not change the caller's pointer. To change where the caller's pointer points, you need one more level: `int**` (pass the pointer's address) or `int*&` (a reference to the pointer).",[84,85,86,87],{"_35":94,"_52":95,"_39":-5,"_54":10},{"_35":92,"_52":93,"_39":-5,"_54":55},{"_35":90,"_52":91,"_39":-5,"_54":55},{"_35":88,"_52":89,"_39":-5,"_54":55},"cmuo4yxnb00uk20jxbchv8cjb","A pointer that cannot move (int* const)","cmuo4yxna00uj20jx0d5vdp85","A reference to int (int&)","cmuo4yxn800ui20jx157dp9o0","A plain pointer (int*), which is enough to change where the caller's pointer points","cmuo4yxn700uh20jx7vjs8shu","A pointer to a pointer (int**) or a reference to a pointer (int*&)","cmuo4yxm900ub20jx56cjnejb","Which line means you cannot change the pointer and cannot change the value it points to?","- **Const pointer to const** (`const int* const p`): you can't change either one.\n\n```cpp\nint x = 1;\nconst int* const cpc = &x; // both fixed\n```\n\nMemory aid: `const` to the left of `*` locks the value it points at; `const` to the right of `*` locks the pointer itself. When `const` appears on both sides, both are locked.","You need two `const`s. `const int` locks the value it points to, and `* const` locks the pointer itself. The versions with one `const` lock only one side. `int const p` is not even a pointer.",[101,102,103,104],{"_35":111,"_52":112,"_39":-5,"_54":55},{"_35":109,"_52":110,"_39":-5,"_54":10},{"_35":107,"_52":108,"_39":-5,"_54":55},{"_35":105,"_52":106,"_39":-5,"_54":55},"cmuo4yxmf00uf20jx4ruoe4n3","const int* p = &x;","cmuo4yxme00ue20jxocyo2hed","int const p = &x;","cmuo4yxmc00ud20jx9917facr","const int* const p = &x;","cmuo4yxma00uc20jxtr46k5a6","int* const p = &x;","cmuo4yxlo00u620jx6s1hfij0","You have `const int* p;`. Which action is not allowed?","Read the declaration from right to left. The `const` locks whatever sits to its left (or to its right if nothing is on its left).\n\n- **Pointer to const** (`const int* p`): you can't change the value through `p`; you can move `p`.\n\n```cpp\nint x = 1, y = 2;\n\nconst int* pc = &x; // pointer to const\n// *pc = 5; // error: value is const through pc\npc = &y; // ok: repoint\n```\n\nMemory aid: `const` to the left of `*` locks the value it points at; `const` to the right of `*` locks the pointer itself.","`const int* p` means p points to an int you are not allowed to change. You can still point p somewhere else, and you can still read the value it points to. Only writing through it, `*p = 5`, is not allowed.",[118,119,120,121],{"_35":128,"_52":129,"_39":-5,"_54":55},{"_35":126,"_52":127,"_39":-5,"_54":55},{"_35":124,"_52":125,"_39":-5,"_54":55},{"_35":122,"_52":123,"_39":-5,"_54":10},"cmuo4yxlv00ua20jxt43qzu2e","*p = 5; (changing the value p points to, through p)","cmuo4yxlt00u920jx983zhn18","p = nullptr;","cmuo4yxls00u820jxk098whmz","p = &other; (pointing p at something else)","cmuo4yxlq00u720jxqe1wmlvz","int y = *p; (reading the value through p)","cmuo4yxlf00u120jxal10ryi8","What does this loop print?","int a[] = {1, 2, 3};\nfor (int* p = a; p != a + 3; ++p)\n std::cout << *p;","cpp","```cpp\nint arr[] = {10, 20, 30, 40};\nint* p = arr; // array decays to pointer to first element\nfor (int* it = arr; it != arr + 4; ++it)\n std::cout << *it << ' '; // 10 20 30 40\n```\n\n`arr + 4` is the pointer just past the last element. You may make it and compare against it, but never dereference it.","`a + 3` points just past the last item. It is a valid place to stop, but the loop never reads the value there. The loop touches a[0] through a[2], so it prints 123.",[137,138,139,140],{"_35":147,"_52":148,"_39":-5,"_54":55},{"_35":145,"_52":146,"_39":-5,"_54":10},{"_35":143,"_52":144,"_39":-5,"_54":55},{"_35":141,"_52":142,"_39":-5,"_54":55},"cmuo4yxln00u520jxg1wwi1qo","012","cmuo4yxll00u420jxkrvdit2c","1231 (it also reads through a + 3)","cmuo4yxlj00u320jx4gqig120","123","cmuo4yxlh00u220jxuk6taix0","Compile error: cannot compare pointers","cmuo4yxku00tw20jxa3ygdumz","What does this program do?","int* p = nullptr;\nstd::cout << *p;","**Undefined behaviour** (the standard says anything may happen): dereferencing a null pointer is undefined behaviour, not a sure crash. `*p` when `p == nullptr` may crash, may wreck memory, or may look fine. Always check before you dereference a pointer that could be null.\n\n```cpp\nint* p = nullptr;\n// std::cout << *p; // UB: never do this\nif (p) std::cout << *p; // safe\n```","Reading a value through an empty (null) pointer is undefined, which means the language promises nothing about what happens. The code does compile. When it runs, the result is not defined (it often crashes, but even that is not promised). It never reliably prints 0.",[155,156,157,158],{"_35":165,"_52":166,"_39":-5,"_54":55},{"_35":163,"_52":164,"_39":-5,"_54":55},{"_35":161,"_52":162,"_39":-5,"_54":10},{"_35":159,"_52":160,"_39":-5,"_54":55},"cmuo4yxl100u020jxn773g09r","It is sure to fail to compile","cmuo4yxkz00tz20jx72l9m0gk","It is undefined: it reads through an empty (null) pointer","cmuo4yxky00ty20jxfv9fkgdj","It prints the address kept in p","cmuo4yxkw00tx20jxh93z0atd","It always prints 0","cmuo4yxkl00tr20jxw3xw7o23","Why is `nullptr` better than `NULL` or `0` for an empty pointer?","**Gotcha:** `NULL` and `0` are integers, so they pick the wrong function. Given `void f(int); void f(char*);`, calling `f(NULL)` runs `f(int)`; `f(nullptr)` runs `f(char*)`, which is what you want.","`NULL` is usually just the number `0`. So if a function has one version that takes a number and one that takes a pointer, calling it with `NULL` might pick the number version by mistake. `nullptr` has its own type (`std::nullptr_t`) that works for any pointer but is never treated as a number, so there is no mix-up.",[172,173,174,175],{"_35":182,"_52":183,"_39":-5,"_54":55},{"_35":180,"_52":181,"_39":-5,"_54":10},{"_35":178,"_52":179,"_39":-5,"_54":55},{"_35":176,"_52":177,"_39":-5,"_54":55},"cmuo4yxks00tv20jxem5s21q6","nullptr sets aside a small marker object to point at","cmuo4yxkr00tu20jx9sfw3f3k","You cannot give NULL or 0 to a pointer at all","cmuo4yxkp00tt20jxukputimq","nullptr has its own pointer type, so it is never mistaken for a number when the compiler picks which version of a function to call","cmuo4yxkn00ts20jxja4djasg","nullptr runs faster because it skips a conversion","cmuo4yxkb00tm20jxrfxxvzvm","Which line gives you a pointer that is sure to be empty (null) in modern C++?","A null pointer points at nothing. Use `nullptr`.\n\n- **`nullptr`** is a typed null (its type is `std::nullptr_t`). It is the right choice.\n- **`NULL`** is a macro (a name the compiler swaps out), usually swapped for `0`. It is really an integer.\n- **`0`** is the plain number zero. It can stand for a null pointer, kept around for old reasons.\n\n```cpp\nint* p = nullptr;\nif (p) { /* skipped: p is null */ }\n```","`nullptr` is the word for an empty pointer. Writing `int* p;` inside a function leaves p holding a junk value, not null. `new int` makes a real object and points at it, so that is not null either.",[189,190,191,192],{"_35":199,"_52":200,"_39":-5,"_54":10},{"_35":197,"_52":198,"_39":-5,"_54":55},{"_35":195,"_52":196,"_39":-5,"_54":55},{"_35":193,"_52":194,"_39":-5,"_54":55},"cmuo4yxkj00tq20jx7s5ym5xg","int* p;","cmuo4yxkh00tp20jxy3mrdoij","int* p = new int;","cmuo4yxkf00to20jxwrnj3b31","int* p = void;","cmuo4yxkd00tn20jx8i92wt8u","int* p = nullptr;","cmuo4yxk200th20jxw5yxze5m","Which of these statements about references and pointers is true?","A reference must be tied to a variable the moment you make it, and you can never point it at something else. A pointer can be null, can be set to a new address, and can walk through arrays.\n\n| Trait | Pointer | Reference |\n|---|---|---|\n| Can be null | yes | no |\n| Rebindable | yes | no |\n| Must init at declaration | no | yes |\n| Syntax to access value | `*p` | `r` (plain use) |\n| Has its own address | yes | it is an alias |","A reference is just another name for a variable that already exists. You must set it when you make it, and it stays tied to that same variable for its whole life. A pointer is its own thing: it can be empty (null), and you can point it at different variables over time.",[206,207,208,209],{"_35":216,"_52":217,"_39":-5,"_54":55},{"_35":214,"_52":215,"_39":-5,"_54":55},{"_35":212,"_52":213,"_39":-5,"_54":10},{"_35":210,"_52":211,"_39":-5,"_54":55},"cmuo4yxk900tl20jxw2qr2kyg","You can leave both a reference and a pointer unset and bind them later","cmuo4yxk700tk20jxaum347vq","You must set a reference when you make it, and you cannot point it at something else later; a pointer can be empty (null) and can be pointed somewhere new","cmuo4yxk600tj20jxra3ombsk","You must set a pointer when you make it, but you need not set a reference","cmuo4yxk400ti20jxsrynlbf5","A reference can be empty (null), but a pointer cannot","cmuo4yxjg00tc20jxku9ar9ni","You have `int x = 10; int* p = &x;`. What does `*p` give you?","- **`&x`** gives you the address of `x`. Its type is \"pointer to whatever `x` is\".\n- **`*p`** dereferences: it reads or writes the value stored at the address in `p`.\n\n```cpp\nint x = 42;\nint* p = &x;\nstd::cout << *p; // 42 (value at the address)\n*p = 7; // writes through p; x is now 7\n```","`&` gives you the address of something. `*` goes to that address and gets what is stored there. `p` holds the address of x, so `*p` follows that address to x and gives you its value, 10.",[223,224,225,226],{"_35":233,"_52":234,"_39":-5,"_54":10},{"_35":231,"_52":232,"_39":-5,"_54":55},{"_35":229,"_52":230,"_39":-5,"_54":55},{"_35":227,"_52":228,"_39":-5,"_54":55},"cmuo4yxjo00tg20jxrgieh5wd","The address of x","cmuo4yxjm00tf20jx1zyes9xp","A copy of the pointer p","cmuo4yxjl00te20jxzs9a6m3d","The address of p itself","cmuo4yxjj00td20jxuyzvkt64","The value kept in x, which is 10","cmuo4yxj500t720jxjtrdkrd2","How do you declare a pointer named `p` that points to an `int`?","A pointer's type tells you what it points at. The `*` is part of how you declare it.\n\n```cpp\nint x = 42;\nint* p = &x; // p holds the address of x\n```\n\nThe `*` sticks to the variable, not the type. So `int* a, b;` makes `a` a pointer but leaves `b` a plain `int`. Declare one pointer per line so you don't fall for this.","To make a pointer, put a `*` between the type it points to and the name: `int* p;`. Writing `int& p;` makes a reference, not a pointer, and it would also need a starting value.",[240,241,242,243],{"_35":249,"_52":250,"_39":-5,"_54":55},{"_35":247,"_52":248,"_39":-5,"_54":55},{"_35":246,"_52":194,"_39":-5,"_54":10},{"_35":244,"_52":245,"_39":-5,"_54":55},"cmuo4yxje00tb20jxdh77kf39","pointer p;","cmuo4yxjd00ta20jxtfxxykqm","cmuo4yxjb00t920jxb70so4or","int p*;","cmuo4yxj900t820jxutk4h7dt","int& p;","cmtym3xyt00gpb1jxv5zd3p80","What does this print?","void reset(int* p) { p = nullptr; }\nint main() {\n int x = 5;\n int* q = &x;\n reset(q);\n std::cout << (q == nullptr ? \"null\" : \"set\");\n}","**Gotcha:** `void reseat(int* p, int* target) { p = target; }` changes nothing the caller can see. `p` is a local copy; the caller's pointer stays the same. You need `int*&` (or `int**`) to re-point it.","`reset` gets a copy of the pointer. Setting the copy to null does not change q, which still points at x. So it prints `set`. To set the caller's pointer to null, you would need `int*&` or `int**`.",[257,258,259,260],{"_35":267,"_52":268,"_39":-5,"_54":55},{"_35":265,"_52":266,"_39":-5,"_54":55},{"_35":263,"_52":264,"_39":-5,"_54":55},{"_35":261,"_52":262,"_39":-5,"_54":10},"cmtym3xz300gtb1jxursicfih","set","cmtym3xz000gsb1jxrtnfc4tg","Compile error","cmtym3xyy00grb1jxiwjyif42","It is undefined","cmtym3xyw00gqb1jxc8eq3b6j","null","cmtym3xy500gfb1jxasdd9vgb","void addOne(int x) { x += 1; }\nvoid addTwo(int& x) { x += 2; }\nint main() {\n int n = 10;\n addOne(n);\n addTwo(n);\n std::cout << n;\n}","Both let a function change the caller's object without making a copy. Pick a reference when the object always exists and you just need to read or change it.\n\n```cpp\nvoid addOne(int& n) { ++n; } // mutate in place\n\nint x = 5;\naddOne(x); // x == 6\n```\n\nA parameter passed by value (like `int n`) is a separate copy: changes made inside the function don't touch the caller's variable. A reference parameter (`int& n`) is another name for the caller's variable, so changes inside the function show up for the caller.","`addOne` takes a copy, so its `x += 1` changes only that copy; n stays the same. `addTwo` takes a reference, so its `x += 2` changes n itself. n = 10 + 2 = 12.",[274,275,276,277],{"_35":284,"_52":285,"_39":-5,"_54":10},{"_35":282,"_52":283,"_39":-5,"_54":55},{"_35":280,"_52":281,"_39":-5,"_54":55},{"_35":278,"_52":279,"_39":-5,"_54":55},"cmtym3xye00gjb1jxhdjrri4s","13","cmtym3xyc00gib1jx3czbu7t8","11","cmtym3xya00ghb1jxpkj425jp","10","cmtym3xy800ggb1jxwkk6k21o","12","cmtym3xxn00gab1jx8ucw577m","What is wrong with this function?","int* makePtr() {\n int local = 42;\n return &local;\n}","A local variable dies when the function returns. A pointer or reference to it is left dangling: it points at memory the program has taken back.\n\n```cpp\nint* bad() {\n int local = 42;\n return &local; // dangling: local is destroyed on return\n}\n```\n\n**Undefined behaviour:** dereferencing that returned pointer is undefined behaviour. It often *seems* to work because nothing has overwritten the memory yet, which makes the bug come and go and hard to track down. Return by value, or point at storage that lives past the call (a buffer the caller gives you, a heap allocation, or a static).\n\n```cpp\nint good() { int local = 42; return local; } // copy out, safe\n```","`local` exists only while the function runs. Once the function returns, `local` is gone, so the returned pointer points at something that no longer exists. Using that pointer is undefined. Nothing leaks (there is no `new`), and taking the address of a local variable is fine.",[292,293,294,295],{"_35":302,"_52":303,"_39":-5,"_54":10},{"_35":300,"_52":301,"_39":-5,"_54":55},{"_35":298,"_52":299,"_39":-5,"_54":55},{"_35":296,"_52":297,"_39":-5,"_54":55},"cmtym3xy300geb1jx8r13jxov","Nothing is wrong; the value 42 comes back safely","cmtym3xy100gdb1jx6tp32xua","It leaks memory because local is never deleted","cmtym3xxx00gcb1jxxo8skvir","It will not compile because you cannot take the address of a local variable","cmtym3xxr00gbb1jx5fteq10q","It returns the address of a local variable, which is destroyed when the function returns; the pointer is left pointing at nothing valid","cmtym3xwz00g0b1jx04qusfrj","What kind of pointer is `int* const p = &x;`?","- **Const pointer** (`int* const p`): you can change the value; you can't move `p`.\n\n```cpp\nint x = 1;\nint* const cp = &x; // const pointer\n*cp = 5; // ok: change value\n// cp = &y; // error: pointer is fixed\n```\n\nMemory aid: `const` to the left of `*` locks the value it points at; `const` to the right of `*` locks the pointer itself.","Read it from right to left. The `const` sits next to the name p, so p itself cannot change (you cannot point it elsewhere). The int it points to is normal, so `*p = ...` is allowed.",[309,310,311,312],{"_35":319,"_52":320,"_39":-5,"_54":10},{"_35":317,"_52":318,"_39":-5,"_54":55},{"_35":315,"_52":316,"_39":-5,"_54":55},{"_35":313,"_52":314,"_39":-5,"_54":55},"cmtym3xx900g4b1jxr91z3tva","A pointer that cannot move and points to an int you cannot change: neither p nor *p can change","cmtym3xx700g3b1jxm0772y3a","A pointer to an int you cannot change: you cannot change *p, but you can point p elsewhere","cmtym3xx400g2b1jxyqevz8co","A normal pointer with no limits","cmtym3xx200g1b1jxtux7ag6x","A pointer that cannot move but points to a normal int: you cannot point p elsewhere, but you can change *p","cmtym3xvj00flb1jxpeo70lqd","int a[] = {10, 20, 30, 40};\nint* p = a;\np += 2;\nstd::cout << *p;","Adding a number to a pointer moves it by whole elements of the pointed-to type, not by bytes. `p + 1` moves ahead by `sizeof(*p)`.\n\n```cpp\nint arr[] = {10, 20, 30, 40};\nint* p = arr; // array decays to pointer to first element\n```","When you add to a pointer, it moves by whole items, not by single bytes. `p` starts at a[0]. `p += 2` moves it forward by two `int`s to a[2], so `*p` is 30.",[326,327,328,329],{"_35":336,"_52":337,"_39":-5,"_54":55},{"_35":334,"_52":335,"_39":-5,"_54":55},{"_35":332,"_52":333,"_39":-5,"_54":10},{"_35":330,"_52":331,"_39":-5,"_54":55},"cmtym3xvy00fpb1jxhfkhaijh","20","cmtym3xvv00fob1jxw308y8ef","30","cmtym3xvq00fnb1jxjcpg86m1","The byte at address a+2","cmtym3xvo00fmb1jxj1z9tukv","40","cmtym3xt400ewb1jxty90nznb","int a = 1, b = 2;\nint& r = a;\nr = b;\nb = 99;\nstd::cout << a << ' ' << b;","A reference must be tied to a variable the moment you make it, and you can never point it at something else.\n\n```cpp\nint a = 1, b = 2;\nint& r = a; // r is another name for a; must init here\nr = b; // does NOT rebind; copies b's value into a. Now a == 2\n```\n\n**Gotcha:** assigning to a reference never points it at a new variable. `r = b` changes the object it stands for. You cannot ever re-point a reference.","Once you set a reference, you cannot make it stand for a different variable. `r = b;` does not make r mean b. It copies b's value into a, the variable r already stands for, so a becomes 2. Later `b = 99;` changes only b. A reference is tied to its variable from the moment you make it.",[343,344,345,346],{"_35":353,"_52":354,"_39":-5,"_54":55},{"_35":351,"_52":352,"_39":-5,"_54":55},{"_35":349,"_52":350,"_39":-5,"_54":55},{"_35":347,"_52":348,"_39":-5,"_54":10},"cmtym3xtj00f0b1jxhxzp71pz","2 99","cmtym3xtg00ezb1jxcnhpxx0a","99 99","cmtym3xta00eyb1jx1n69bogc","2 2","cmtym3xt700exb1jx0qeozksd","1 99","email"]