WEBVTT 1 00:00:00.080 --> 00:00:04.120 Imagine cutting through the noise of a dense C plus 2 00:00:04.160 --> 00:00:09.039 plus textbook, right skipping past all the really heavy explanations 3 00:00:09.519 --> 00:00:13.800 and just finding those shimmering nuggets of insight that actually matter. 4 00:00:14.039 --> 00:00:15.759 Yeah, that's pretty much what we're aming for today. 5 00:00:15.800 --> 00:00:16.719 Welcome to the deep dive. 6 00:00:16.920 --> 00:00:20.960 We've taken this comprehensive guide to C plus plus you shared, 7 00:00:21.280 --> 00:00:25.120 which is packed with examples and detailed explanations, and our 8 00:00:25.199 --> 00:00:28.399 mission really is to distill that make it understandable and 9 00:00:28.760 --> 00:00:31.440 you know, immediately applicable for you exactly. 10 00:00:31.879 --> 00:00:34.640 So, whether you're maybe just starting out with programming or 11 00:00:34.640 --> 00:00:39.159 you're looking to really solidify your C plus plus understanding, 12 00:00:39.439 --> 00:00:41.600 we're going to try and pull out the most impactful, 13 00:00:41.719 --> 00:00:44.719 maybe surprising, and just genuinely useful bits. 14 00:00:44.880 --> 00:00:46.759 Yeah, the goal isn't just a summary. We want you 15 00:00:46.759 --> 00:00:49.520 to get the why behind these concepts, how they fit 16 00:00:49.560 --> 00:00:52.920 into the bigger picture of building you know, robust and efficient. 17 00:00:52.560 --> 00:00:55.079 Software, Getting those aha moments. 18 00:00:54.719 --> 00:00:57.840 Absolutely, those moments that turn a definition into real insight. 19 00:00:57.960 --> 00:00:59.880 All right, let's kick things off right at the beginning, 20 00:01:00.159 --> 00:01:03.520 getting your code to actually do something. You've written your program, 21 00:01:03.880 --> 00:01:07.719 probably in a dot cc file. What's the first hurdle? 22 00:01:07.799 --> 00:01:09.519 How do you make the computer understand it well? 23 00:01:09.560 --> 00:01:11.879 The first step is compilation. You'll usually go to your 24 00:01:11.920 --> 00:01:15.519 command line type something like ccprog one dot cc. What 25 00:01:15.640 --> 00:01:18.840 happens then kind of depends on your system. Right on Windows, 26 00:01:18.920 --> 00:01:23.519 you'll typically get an executable file, probably named prog one 27 00:01:23.640 --> 00:01:27.280 dot ex okay, But if you're on a Unix like system, 28 00:01:27.640 --> 00:01:30.760 the compiler often just spits out a generic file called 29 00:01:30.799 --> 00:01:32.040 a dot out. 30 00:01:31.879 --> 00:01:34.519 A dot out, got it, and then the fun part 31 00:01:34.599 --> 00:01:38.560 running it. On Windows, you just type prog one usually. 32 00:01:38.319 --> 00:01:41.640 Yeah, often without the dot ex. But here's a little 33 00:01:41.640 --> 00:01:45.000 snag that often gets beginners. Depending on how your system's 34 00:01:45.000 --> 00:01:46.760 set up, you might need to be explicit about where 35 00:01:46.760 --> 00:01:48.760 the program is, like, tell the shell to look right 36 00:01:48.799 --> 00:01:50.000 here in the current directory. 37 00:01:50.079 --> 00:01:52.480 Ah, so that's the prog one on Windows or a 38 00:01:52.599 --> 00:01:54.760 dot out on Unix exactly. 39 00:01:54.959 --> 00:01:57.519 That little dot slash just means look in this folder. 40 00:01:57.599 --> 00:01:59.159 It's a small thing, but crucial. 41 00:01:59.439 --> 00:02:01.159 And what about after it runs? How do you know 42 00:02:01.200 --> 00:02:03.280 if it worked or you know if something went wrong? 43 00:02:03.439 --> 00:02:06.200 Right? The exit status? That also varies. On Unx, you 44 00:02:06.239 --> 00:02:08.280 type echo dollars to see the status code. 45 00:02:08.360 --> 00:02:08.639 Okay. 46 00:02:08.719 --> 00:02:11.360 On Windows, the command is different. It's echo percent or 47 00:02:11.560 --> 00:02:17.280 level percent understanding this basic handshake, compile, run check the status. 48 00:02:18.479 --> 00:02:21.199 It's well, it's fundamental. You need it to actually build 49 00:02:21.240 --> 00:02:23.039 and debug anything makes sense. 50 00:02:23.120 --> 00:02:24.960 Once you've got that down, you start looking at the 51 00:02:24.960 --> 00:02:27.639 code itself. And it's funny how even simple things like 52 00:02:27.719 --> 00:02:31.280 comments can have these weird little traps. Your source material 53 00:02:31.280 --> 00:02:33.879 actually points this out with some cool exercises. Yeah, like 54 00:02:33.960 --> 00:02:37.400 one on incorrectly nested comments, and then this one std 55 00:02:37.520 --> 00:02:39.080 dot count will cocout. 56 00:02:39.400 --> 00:02:40.719 Why is that one so tricky? 57 00:02:41.080 --> 00:02:44.319 Ah, that's a brilliant example of C plus plus OS precision. 58 00:02:45.039 --> 00:02:48.840 Or you could say it's literal mindedness. Okay, we look 59 00:02:48.879 --> 00:02:50.879 at and we mentally parse it. Right, we see the 60 00:02:50.879 --> 00:02:53.360 command and then the end do But the compiler just 61 00:02:53.680 --> 00:02:57.039 reads characters. It sees DAWs starts a comment, then it 62 00:02:57.080 --> 00:02:59.599 sees inside the quote marks the things. That's the end 63 00:02:59.599 --> 00:03:01.719 of the comment. Then the full laws that follows is 64 00:03:01.800 --> 00:03:06.360 just junk outside of any comment syntax error. Wow. Okay, 65 00:03:06.439 --> 00:03:08.639 so it just sees the first and stops, leaving the 66 00:03:08.639 --> 00:03:10.199 second one hanging exactly. 67 00:03:10.479 --> 00:03:14.639 It shows just how precise, even unforgiving the syntax is 68 00:03:15.319 --> 00:03:16.680 no guessing allowed. 69 00:03:16.840 --> 00:03:20.520 So even comments need care. Okay, beyond that, and basic 70 00:03:20.560 --> 00:03:24.639 output with std dot count. Understanding program flow is vital. 71 00:03:25.080 --> 00:03:27.639 Code doesn't just run top to bottom like a shopping list. 72 00:03:28.000 --> 00:03:31.199 No, that would be incredibly limiting. You need control flow, 73 00:03:31.719 --> 00:03:33.879 and the main tools for that are the wile and 74 00:03:34.039 --> 00:03:37.479 if statements. They let you make decisions and repeat actions. 75 00:03:37.199 --> 00:03:40.520 Right like the example in the source for counting consecutive 76 00:03:40.560 --> 00:03:41.759 inputs precisely. 77 00:03:41.960 --> 00:03:44.000 That's a great example. It uses an if for the 78 00:03:44.120 --> 00:03:47.319 very first number, then a wile loop, probably with another 79 00:03:47.360 --> 00:03:49.520 if inside, to keep reading numbers as long as they're 80 00:03:49.560 --> 00:03:49.840 the same. 81 00:03:49.919 --> 00:03:51.719 So it tracks the current value in its. 82 00:03:51.560 --> 00:03:54.599 Count yeah, and prints the summary when the value finally changes. 83 00:03:54.840 --> 00:03:57.599 It really shows how you combine these simple if and 84 00:03:57.680 --> 00:03:59.719 wileblocks to build practical logic. 85 00:04:00.000 --> 00:04:02.719 And this brings up formatting. The compiler might not care 86 00:04:02.759 --> 00:04:04.080 if your code looks like spaghetti. 87 00:04:04.159 --> 00:04:05.520 Hey nope, not one bit. 88 00:04:05.560 --> 00:04:10.400 But humans sure doo. Readability, consistency, it's crucial, right, especially 89 00:04:10.439 --> 00:04:12.879 for your future self or anyone else trying to understand 90 00:04:12.879 --> 00:04:15.560 it later. Bad formatting can hide bugs. 91 00:04:15.639 --> 00:04:20.720 Oh, absolutely, think of code as communication. Clear communication prevents misunderstandings, 92 00:04:20.759 --> 00:04:25.000 prevents errors. Getting these fundamentals right both function and form 93 00:04:25.199 --> 00:04:25.639 is key. 94 00:04:25.800 --> 00:04:29.600 Okay, moving Beyond those core mechanics, let's talk about organizing 95 00:04:29.680 --> 00:04:33.399 data in a more sophisticated way. C plus plus has 96 00:04:33.399 --> 00:04:36.600 classes for this. What exactly is a class? Why is 97 00:04:36.639 --> 00:04:40.199 it such a big deal compared to just using say 98 00:04:40.279 --> 00:04:40.879 an integer. 99 00:04:41.120 --> 00:04:44.160 A class is basically your way to invent new types 100 00:04:44.199 --> 00:04:46.759 of data in C plus plus A it lets you 101 00:04:46.800 --> 00:04:50.279 bundle together related pieces of information like a books title, 102 00:04:50.399 --> 00:04:53.319 author and price, and the actions you can perform on 103 00:04:53.360 --> 00:04:55.279 that information, like calculating a discount. 104 00:04:55.319 --> 00:04:57.399 So data and operations together exactly. 105 00:04:57.439 --> 00:04:59.519 It's a huge feature because it lets you model real 106 00:04:59.519 --> 00:05:01.759 world thing directly in your code. You're not just juggling 107 00:05:01.839 --> 00:05:04.879 numbers anymore. You're creating these little, self contained objects that 108 00:05:04.920 --> 00:05:09.000 represent concepts from your problem. Makes programs way more intuitive. 109 00:05:09.279 --> 00:05:12.120 That makes sense, So using something like the sales item 110 00:05:12.120 --> 00:05:15.199 class for bookstore sales the sources, you really only need 111 00:05:15.240 --> 00:05:18.759 three things to use it. Its name, where it's definition lives, 112 00:05:18.920 --> 00:05:22.040 usually a header file, and what operations it supports. 113 00:05:22.199 --> 00:05:25.040 Right, you don't necessarily need to know the internal plumbing, 114 00:05:25.120 --> 00:05:27.680 just the public interface how to interact with it. 115 00:05:28.040 --> 00:05:31.160 And these definitions usually go in header files, often ending 116 00:05:31.199 --> 00:05:36.240 in h dot HPP or dot hxx. But standard library 117 00:05:36.240 --> 00:05:38.240 headers like iostream don't have an ending. 118 00:05:38.439 --> 00:05:41.560 Yeah, that's the convention. It helps distinguish your custom types 119 00:05:41.600 --> 00:05:44.879 from the standard ones. It's a big conceptual leap learning to. 120 00:05:44.959 --> 00:05:47.720 Use classes, but we still need the basic building blocks. 121 00:05:47.720 --> 00:05:51.879 The variables. Primitives like characters, integers, floats, and even integers 122 00:05:51.879 --> 00:05:54.959 have quirks, right, like twenty zero, twenty four and zero 123 00:05:55.120 --> 00:05:56.759 x fourteen all being the same value. 124 00:05:56.879 --> 00:05:59.600 Yeah, that's a fun one. They all represent twenty twenty 125 00:05:59.680 --> 00:06:02.720 is desk standard base ten zero two four with the 126 00:06:02.800 --> 00:06:06.040 leading zero tells the compiler it's octal base eight and 127 00:06:06.120 --> 00:06:10.160 zero by fourteen is hexadecimal base sixteen. Usually does it matter, 128 00:06:10.199 --> 00:06:13.040 but sometimes the notation itself implies a different default type, 129 00:06:13.079 --> 00:06:14.079 which can be surprising. 130 00:06:14.360 --> 00:06:19.959 And initialization this seems like a minefield, especially inside functions. 131 00:06:19.959 --> 00:06:22.680 Oh, it can be if you declare, say an end 132 00:06:22.800 --> 00:06:25.079 inside of function and forget to give it a value. 133 00:06:25.439 --> 00:06:29.920 Its value is technically undefined, not zero, Nope, not guaranteed 134 00:06:29.959 --> 00:06:32.160 to be zero. It could be anything that was previously 135 00:06:32.160 --> 00:06:36.079 in that memory location. Using it leads to unpredictable behavior, 136 00:06:36.439 --> 00:06:38.959 really hard to find bugs. It's like assuming an empty 137 00:06:39.000 --> 00:06:40.680 box has what you need inside. 138 00:06:40.759 --> 00:06:43.959 Risky but global variables are zero initialized. 139 00:06:44.120 --> 00:06:48.399 Generally yes, built in types outside functions get zero initialized, 140 00:06:48.680 --> 00:06:52.079 and classes well, they handle their own initialization through constructors. 141 00:06:52.160 --> 00:06:55.680 Okay, Then you have compound types like pointers and the 142 00:06:55.720 --> 00:06:57.360 symbols and doing double duty. 143 00:06:57.480 --> 00:07:00.439 Right. That confuses people In t declares, P is a 144 00:07:00.480 --> 00:07:03.839 pointer to an ind but later phqal five uses the 145 00:07:04.000 --> 00:07:06.399 to de reference the pointer to access the memory location. 146 00:07:06.519 --> 00:07:09.759 P points to same symbol, different job depending on context. 147 00:07:09.879 --> 00:07:11.720 And null pointers are critical. 148 00:07:11.519 --> 00:07:14.759 Absolutely critical. You can get one using olptr that's the 149 00:07:14.920 --> 00:07:18.680 modern C plus plus way, or sometimes just zero or 150 00:07:18.720 --> 00:07:22.160 the older null macro. The key is always check if 151 00:07:22.199 --> 00:07:24.279 a pointer is null before you try to use on it. 152 00:07:24.680 --> 00:07:27.480 Dear referencing a null pointer is usually an instant crash. 153 00:07:27.560 --> 00:07:31.959 To make things safer, we have cost and constexper const 154 00:07:32.000 --> 00:07:35.120 means a value can't be changed after initialization, right. 155 00:07:35.319 --> 00:07:38.199 And consextper goes further. It means the value must be 156 00:07:38.240 --> 00:07:40.639 known at compile time. The compiler has to be able 157 00:07:40.680 --> 00:07:42.600 to figure it out before the program even runs. 158 00:07:42.879 --> 00:07:46.160 Interesting that some things like sales item or standard iostreams 159 00:07:46.480 --> 00:07:48.920 can't be const exper They're not literal types. 160 00:07:49.040 --> 00:07:52.120 Yeah, they rely on runtime state or operations that just 161 00:07:52.160 --> 00:07:56.240 aren't fixed at compile time. Also, context per pointers have restrictions. 162 00:07:56.279 --> 00:07:59.199 They generally have to point to objects with fixed memory addresses, 163 00:07:59.279 --> 00:08:00.720 not local very on the stack. 164 00:08:00.879 --> 00:08:05.560 So understanding these type details initialization pointers const is fundamental 165 00:08:05.560 --> 00:08:07.560 to avoiding those nasty subtle bugs. 166 00:08:07.639 --> 00:08:10.879 It really is const and cons textper help the compiler 167 00:08:11.000 --> 00:08:13.879 enforce guarantees for you making code safer, but you need 168 00:08:13.920 --> 00:08:14.720 to know their rules. 169 00:08:14.959 --> 00:08:17.920 Okay. When unique collections of data, the standard library gives 170 00:08:17.959 --> 00:08:21.240 you great tools. String is the obvious one for text, 171 00:08:21.480 --> 00:08:23.839 and like the int example earlier, you can read lots 172 00:08:23.879 --> 00:08:26.279 of strings without knowing how many beforehand. 173 00:08:25.920 --> 00:08:28.560 Very flexible. And then there's vector, which is like a 174 00:08:28.639 --> 00:08:32.320 dynamic array. It can grow or shrink as needed. Modern 175 00:08:32.399 --> 00:08:35.159 C plus plus lets you initialize them nicely with curly 176 00:08:35.200 --> 00:08:37.840 braces like vectorant v one two three clean. 177 00:08:38.080 --> 00:08:41.080 But vectors have a dark side, right yeah, subscripting. 178 00:08:40.679 --> 00:08:44.360 Ah, yes, the danger zone. The source gives this example 179 00:08:44.519 --> 00:08:47.720 vectorant of a C two ten cut evac two ten. 180 00:08:47.960 --> 00:08:48.759 What's wrong there? 181 00:08:48.879 --> 00:08:51.639 Well, ivac two has ten elements, so the valid indicase 182 00:08:51.679 --> 00:08:54.639 are zero through nine. Ivax two ten is one. 183 00:08:54.519 --> 00:08:56.679 Past the end exactly, it's out of bounds. And the 184 00:08:56.720 --> 00:08:59.279 really scary part the compiler probably won't warn you. 185 00:08:59.559 --> 00:09:01.200 It just compiles often. 186 00:09:01.039 --> 00:09:03.440 Yes, and at runtime you get undefined behavior. 187 00:09:03.559 --> 00:09:05.679 And undefined behavior isn't just a crash, is it. It 188 00:09:05.679 --> 00:09:06.840 could be worse, much worse. 189 00:09:06.919 --> 00:09:09.440 It means anything could happen. It might crash. It might 190 00:09:09.480 --> 00:09:11.559 seem to work fine on your machine but crash later. 191 00:09:11.639 --> 00:09:14.960 For a user, it might silently corrupt other data or 192 00:09:15.360 --> 00:09:16.960 and this is the big one, it could create a 193 00:09:17.000 --> 00:09:20.759 security hole because you might be reading or writing memory 194 00:09:20.799 --> 00:09:23.399 that doesn't belong to the vector. This is the classic 195 00:09:23.480 --> 00:09:27.000 buffer overflow. The source rightly calls it the most common 196 00:09:27.039 --> 00:09:31.360 cause of security problems. Accessing IVEC two ten could potentially 197 00:09:31.399 --> 00:09:35.639 overwrite crucial program data or even allow malicious code execution. 198 00:09:35.879 --> 00:09:36.879 It's a huge deal. 199 00:09:37.200 --> 00:09:40.000 Wow. Okay, that really hammers home why bounds checking is 200 00:09:40.039 --> 00:09:43.279 so important. So compared to flexible vectors, we also have 201 00:09:43.360 --> 00:09:45.559 plane old arrays fixed size. 202 00:09:45.320 --> 00:09:48.360 YEP built in a arrays fixed size determined at compile time. 203 00:09:48.799 --> 00:09:51.120 You typically use size it for indices, which is an 204 00:09:51.200 --> 00:09:54.639 unsigned type suitable for sizes. You can have multidimensional ones. 205 00:09:54.440 --> 00:09:57.080 Too, But the source in exercise three point twenty nine 206 00:09:57.399 --> 00:09:58.720 kind of hints they have drawbacks. 207 00:09:58.720 --> 00:10:01.480 They do raw rays lie lack the flexibility and safety 208 00:10:01.519 --> 00:10:03.919 features of vector. They don't know their own size, they 209 00:10:03.919 --> 00:10:07.039 decay into pointers easily, and managing their memory manually is 210 00:10:07.159 --> 00:10:09.960 error prone. That's why vector is almost always referred to 211 00:10:10.039 --> 00:10:13.480 Modern C plus plus ibros. Arrays have their place, but 212 00:10:13.519 --> 00:10:15.879 you need to be aware of the pitfalls. 213 00:10:15.480 --> 00:10:19.440 To navigate these containers vectors, strings, etc. We have iterators. 214 00:10:19.799 --> 00:10:22.200 You describe them as like a smart pointer or GPS 215 00:10:22.200 --> 00:10:22.799 for data. 216 00:10:22.919 --> 00:10:25.759 Yeah, that's a good analogy. An iterator points to an 217 00:10:25.799 --> 00:10:28.960 element within a container. You use the star operator to 218 00:10:28.960 --> 00:10:32.279 get the element's value be referencing, and the plus plus 219 00:10:32.320 --> 00:10:34.480 plus plus operator to move to the next element. 220 00:10:34.639 --> 00:10:36.919 And the cool thing is they work across different containers. 221 00:10:37.039 --> 00:10:41.360 That's the power. They provide a uniform interface. The code 222 00:10:41.399 --> 00:10:44.960 to loop through a vector using iterators looks very similar 223 00:10:45.000 --> 00:10:48.200 to code lipping through a list or a deck. Some iterators, 224 00:10:48.240 --> 00:10:51.559 like those for straying, vector deck and array, even support arithmetic. 225 00:10:51.799 --> 00:10:54.360 You can jump forward five elements, for instance. 226 00:10:54.000 --> 00:10:56.799 And there are different kinds like read only ones. 227 00:10:56.919 --> 00:11:00.000 Yep, you have iterator for read write access. Can still 228 00:11:00.000 --> 00:11:02.360 iterator for rate only safer if you don't need to 229 00:11:02.360 --> 00:11:06.440 modify and even reverse iterator to go backwards using prey 230 00:11:06.440 --> 00:11:10.440 again and send always gives you considerators. This generalization makes 231 00:11:10.480 --> 00:11:12.320 algorithms incredibly reusable. 232 00:11:12.440 --> 00:11:14.879 It makes sense. And strings aren't just for basic io. 233 00:11:15.000 --> 00:11:16.679 They have advanced operations too. 234 00:11:16.759 --> 00:11:20.759 Oh yeah, things like append a sign, insert, replace give 235 00:11:20.840 --> 00:11:24.639 you fine grain control over modifying string content and searching. 236 00:11:24.799 --> 00:11:27.519 The fine function is key. You give it a substring 237 00:11:27.759 --> 00:11:30.240 and it returns the starting position, which is a string 238 00:11:30.440 --> 00:11:33.919 dot size type, an unsigned value, or a special value 239 00:11:33.960 --> 00:11:37.519 called in pauses. If the substring isn't found, remember it's 240 00:11:37.600 --> 00:11:41.080 case sensitive. Find won't find find these tools let you 241 00:11:41.120 --> 00:11:43.039 do some pretty sophisticated text processing. 242 00:11:43.120 --> 00:11:46.200 Okay, we've covered basics data structures. Let's get into the 243 00:11:46.200 --> 00:11:49.519 more advanced stuff. Operators they're everywhere c plus plus foe 244 00:11:49.600 --> 00:11:52.320 and not just for math into your division. For example, 245 00:11:52.679 --> 00:11:53.919 ten three is three. 246 00:11:53.919 --> 00:11:57.240 Right truncation, It just chops off the fractional part. No 247 00:11:57.399 --> 00:11:59.559 rounding can definitely catch you off guard if you expect 248 00:11:59.639 --> 00:12:00.759 floating point behavior. 249 00:12:00.919 --> 00:12:04.320 And what about signed integer wrap around the source manages three, two, seven, six, 250 00:12:04.440 --> 00:12:06.279 eight becoming positive if you subtract one. 251 00:12:06.519 --> 00:12:09.679 Ah yeah, that's about integer overflow with signed types. If 252 00:12:09.759 --> 00:12:13.240 you go below the minimum value like NACS three two, seven, 253 00:12:13.320 --> 00:12:16.120 six eight for a sixteen bit short. The behavior is 254 00:12:16.159 --> 00:12:19.679 technically undefined in standards C plus plus set. It might 255 00:12:19.679 --> 00:12:22.440 wrap around to the maximum positive value on some systems, 256 00:12:22.519 --> 00:12:25.240 or it might crash or do something else weird. It 257 00:12:25.320 --> 00:12:28.039 highlights that C plus plus operates close to the hardware, 258 00:12:28.120 --> 00:12:29.679 and you need to be careful about the limits of 259 00:12:29.720 --> 00:12:33.159 your types. Unsigned integers, however, are defined to wrap around 260 00:12:33.240 --> 00:12:33.879 good distinction. 261 00:12:34.000 --> 00:12:36.679 Another operator is the conditional operator. 262 00:12:36.320 --> 00:12:39.759 De ternary operator yeah, superconcise for simple of false assignments 263 00:12:39.919 --> 00:12:43.759 result condition and value value of false. Very handy and 264 00:12:43.879 --> 00:12:47.840 bitwise operators yeah yeah for manipulating individual bits left shift, 265 00:12:47.919 --> 00:12:48.759 right shift, viz. 266 00:12:49.000 --> 00:12:49.639 Not aid. 267 00:12:51.279 --> 00:12:54.120 One key detail is that right shifting as signed negative 268 00:12:54.159 --> 00:12:57.080 number is implementation defined. It might fill the new bits 269 00:12:57.120 --> 00:13:00.919 with one's arithmetic shift or zero's logical shift. Write shifting 270 00:13:00.919 --> 00:13:04.080 an unsigned number always fills with zeros, important if you're 271 00:13:04.080 --> 00:13:05.919 doing low level bit tooidly CEE. 272 00:13:05.759 --> 00:13:08.559 Plus plus also has explicit type conversions, the. 273 00:13:08.639 --> 00:13:11.799 Casts right stata cast is the most common used for 274 00:13:11.879 --> 00:13:15.039 sensible conversions like int to double or up down an 275 00:13:15.039 --> 00:13:18.799 inheritance hierarchy when you know it's safe. Const cast is 276 00:13:18.840 --> 00:13:22.080 specifically for removing cost, usually a sign you should rethink 277 00:13:22.120 --> 00:13:24.879 your design, but sometimes necessary. 278 00:13:24.360 --> 00:13:27.120 And the dangerous one reinterpret cast. 279 00:13:27.279 --> 00:13:30.039 Yeah, that's the break glass in case of emergency cast. 280 00:13:30.399 --> 00:13:33.799 It tells the compiler to just reinterpret the raw bits 281 00:13:33.799 --> 00:13:35.960 of one type as if they were another type, even 282 00:13:36.000 --> 00:13:39.600 if they're completely unrelated. Like your analogy telling it. English 283 00:13:39.600 --> 00:13:43.240 text is actually ancient Greek. It's powerful for low level stuff, 284 00:13:43.279 --> 00:13:46.799 but incredibly easy to misuse and cause crashes or weird behavior. 285 00:13:47.279 --> 00:13:49.279 Avoid unless you absolutely have to. 286 00:13:49.559 --> 00:13:53.120 What's really cool is operator overloading. Defining what plus or 287 00:13:53.240 --> 00:13:55.399 means for your own classes like sale. 288 00:13:55.159 --> 00:13:58.360 Side exactly, you can make your custom types behave intuitively, 289 00:13:58.600 --> 00:14:00.919 item one plus item two could some sales item one, 290 00:14:01.000 --> 00:14:04.000 egles item too could compare isbn's makes code. 291 00:14:03.840 --> 00:14:06.039 Very readable, but you can't mess with built in types 292 00:14:06.240 --> 00:14:07.759 like redefining NT plus NT. 293 00:14:08.000 --> 00:14:10.720 Thankfully no, that would be chaos. You can only overload 294 00:14:10.759 --> 00:14:13.519 operators where at least one operand is a user defined type, 295 00:14:13.759 --> 00:14:14.840 a class or enom. 296 00:14:15.120 --> 00:14:17.440 What operators are commonly overloaded. 297 00:14:17.159 --> 00:14:22.279 Well, arithmetic operators plus aisle, comparison operators, assignment, subscript function 298 00:14:22.399 --> 00:14:26.840 call stream insertion extraction. Defining is often useful for custom 299 00:14:26.919 --> 00:14:29.399 classes so they can be easily sorted or used in 300 00:14:29.559 --> 00:14:31.840 ordered containers like std dot map. 301 00:14:31.840 --> 00:14:35.279 And the function call operate operator that makes an object 302 00:14:35.279 --> 00:14:36.559 act like a function. Yeah. 303 00:14:36.679 --> 00:14:39.639 It lets you create function objects or functors. You can 304 00:14:39.679 --> 00:14:43.000 instance an object and then call it with parentheses like 305 00:14:43.279 --> 00:14:47.360 myfunctor R one R two. It's a precursor to lambdas 306 00:14:47.440 --> 00:14:50.519 and heavily used in the standard library, especially with algorithms. 307 00:14:50.600 --> 00:14:54.000 So operators are fundamental and customizing them as powerful. Let's 308 00:14:54.000 --> 00:14:57.399 talk functions the workhorses, like the example for factors. 309 00:14:57.440 --> 00:15:00.960 Simple function call takes an argument, returns about the basic 310 00:15:01.120 --> 00:15:02.320 unit of code organization. 311 00:15:02.480 --> 00:15:04.399 And for bigger projects you split code up. 312 00:15:04.480 --> 00:15:09.279 Separate compilation absolutely essential. You put declarations in header files 313 00:15:09.360 --> 00:15:13.919 JOJHPP and definitions in source files dot CC, dot CPP. 314 00:15:14.159 --> 00:15:16.759 You compile source files individually and then link them together. 315 00:15:17.159 --> 00:15:19.120 If you only change one file, you only need to 316 00:15:19.159 --> 00:15:22.600 recompile that one file, not the whole project. Saves tons 317 00:15:22.600 --> 00:15:22.960 of time. 318 00:15:23.120 --> 00:15:27.000 And how you pass arguments matters pass by value versus 319 00:15:27.120 --> 00:15:29.360 pass by reference huge difference. 320 00:15:29.440 --> 00:15:31.799 Pass by value makes a copy of the argument. The 321 00:15:31.840 --> 00:15:34.720 function works on the copy. The original outside the function 322 00:15:34.840 --> 00:15:39.360 is untouched. Pass by reference using in the parameter type 323 00:15:39.399 --> 00:15:43.600 like void reset into passes the actual variable. The function 324 00:15:43.720 --> 00:15:46.799 can directly modify the original variable and the caller scope. 325 00:15:47.240 --> 00:15:49.279 Use reference when you want the function to change the 326 00:15:49.399 --> 00:15:52.320 argument or for large objects to avoid the cost of copying. 327 00:15:52.480 --> 00:15:54.960 In functions return arrays not directly. 328 00:15:55.080 --> 00:15:57.519 You can't declare a function to return an array type, 329 00:15:57.799 --> 00:15:59.960 but you can return a pointer to the first l 330 00:16:00.000 --> 00:16:02.759 element of an array or reference to an array, or 331 00:16:02.960 --> 00:16:06.480 better yet, return a std dot vector or std dot array. 332 00:16:06.639 --> 00:16:11.840 C plus plus also has overloaded functions same name, different parameters. 333 00:16:11.559 --> 00:16:15.120 Right, like having print double and print constring. The compiler 334 00:16:15.120 --> 00:16:17.159 figures out which want to call based on the arguments 335 00:16:17.159 --> 00:16:22.919 you provide. Even constants can differentiate overloads. Void foo sorts 336 00:16:22.960 --> 00:16:26.600 wiget in and void food conswigit in are different functions. 337 00:16:26.279 --> 00:16:29.440 And inside member functions there's this pointer. Yep. 338 00:16:29.919 --> 00:16:33.399 This is an implicit pointer available inside every non static 339 00:16:33.519 --> 00:16:36.919 member function. It points to the specific object the member 340 00:16:36.919 --> 00:16:39.720 function was called on. Is how the function knows which 341 00:16:39.720 --> 00:16:43.519 objects data to access, and this itself is a constant pointer. 342 00:16:43.639 --> 00:16:46.120 You can change the data points to, but you can't 343 00:16:46.120 --> 00:16:47.840 make this point to a different object. 344 00:16:48.000 --> 00:16:49.799 What about constant member functions? 345 00:16:50.080 --> 00:16:53.440 AH very important If you declare a member function with 346 00:16:53.480 --> 00:16:56.559 const after the parameter list like double salees, item, dot, ivery, 347 00:16:56.600 --> 00:16:59.759 g price, const, you're promising that this function will not 348 00:16:59.759 --> 00:17:02.440 show change any data members of the object. It's read only. 349 00:17:03.039 --> 00:17:05.720 This lets you call the function on const objects and 350 00:17:05.759 --> 00:17:07.279 improves safety and clarity. 351 00:17:07.480 --> 00:17:10.519 Then there are constructors for initializing objects. Yeah, the source 352 00:17:10.599 --> 00:17:12.400 really emphasizes initializer lists. 353 00:17:12.799 --> 00:17:17.680 Yes. Constructor initializer lists number one, vowel one, member two, 354 00:17:17.839 --> 00:17:21.640 valve two are the preferred way to initialize members. They 355 00:17:21.680 --> 00:17:25.720 initialize members before the constructor body starts executing. This is 356 00:17:25.799 --> 00:17:29.160 crucial for cost members, reference members, and often more efficient 357 00:17:29.200 --> 00:17:30.240 for class type members. 358 00:17:30.559 --> 00:17:33.680 And the order matters, but not the order in the 359 00:17:33.720 --> 00:17:34.359 list correct. 360 00:17:34.440 --> 00:17:36.799 That's a common trap. Members are initialized in the order 361 00:17:36.799 --> 00:17:39.440 they are declared in the class definition, regardless of the 362 00:17:39.519 --> 00:17:42.240 order in the initializer list. Get the list order wrong 363 00:17:42.359 --> 00:17:45.240 relative to the declaration order, and you can get subtle 364 00:17:45.240 --> 00:17:48.240 bugs if one member's initialization depends on another. 365 00:17:48.680 --> 00:17:51.079 You can also have default arguments and constructors. 366 00:17:51.319 --> 00:17:55.960 Yeah, like sales, data, std dot string s equals this. 367 00:17:56.000 --> 00:17:58.960 One constructor can now act as the default constructor if 368 00:17:59.000 --> 00:18:02.160 called with no arguments or take a string argument. Very 369 00:18:02.160 --> 00:18:05.440 flexible and you can have delegating constructors where one constructor 370 00:18:05.480 --> 00:18:08.119 calls another in the same class using the initializer list 371 00:18:08.119 --> 00:18:11.039 syntax to avoid repeating common setup code. 372 00:18:11.200 --> 00:18:13.079 What about friend functions or classes. 373 00:18:13.519 --> 00:18:17.680 Friend declarations grant special access. A function or another class 374 00:18:17.720 --> 00:18:20.720 declared as a friend inside class A can access a's 375 00:18:20.799 --> 00:18:25.519 private and protected members. It breaks encapsulation, so use it sparingly. 376 00:18:25.920 --> 00:18:29.119 But sometimes it's the cleanest solution, especially for things like 377 00:18:29.279 --> 00:18:33.480 operator overloading. Like operator and even if you define a 378 00:18:33.519 --> 00:18:37.200 friend function entirely inside the class body, you usually still 379 00:18:37.240 --> 00:18:39.839 need a separate declaration outside the class to make it 380 00:18:39.960 --> 00:18:41.960 visible in the surrounding scope. 381 00:18:41.599 --> 00:18:45.319 And name resolution. Names inside a class can hide names 382 00:18:45.359 --> 00:18:45.960 from outside. 383 00:18:46.039 --> 00:18:49.079 Yes, s popes matter. If a member function uses a name, 384 00:18:49.319 --> 00:18:52.519 the compiler looks first within the function, then within the class, 385 00:18:52.599 --> 00:18:55.480 then in outer scopes. A member name can hide a 386 00:18:55.559 --> 00:18:59.319 global variable or function with the same name. Understanding scope 387 00:18:59.319 --> 00:19:02.240 resolution rules is key to avoiding confusion. 388 00:19:02.559 --> 00:19:07.200 Mastering all these function aspects. Overloading const constructor's scope is 389 00:19:07.279 --> 00:19:09.720 really crucial for well structured C plus plus code. 390 00:19:09.799 --> 00:19:12.559 Absolutely, they're the building blocks of your program's architecture. 391 00:19:12.599 --> 00:19:15.440 Okay, let's tackle a big topic, memory management. We have 392 00:19:15.480 --> 00:19:18.920 the stack for local variables automatically managed. But then there's 393 00:19:18.920 --> 00:19:20.279 the heap or free. 394 00:19:20.039 --> 00:19:24.680 Store right where you dynamically allocate memory using new objects 395 00:19:24.680 --> 00:19:28.759 created with new live until you explicitly destroy them using delete. 396 00:19:28.599 --> 00:19:31.680 And forgetting to delete leads to memory leaks. Doing it 397 00:19:31.720 --> 00:19:33.839 wrong leads to crashes exactly. 398 00:19:34.359 --> 00:19:37.880 Manual memory management is notoriously error prone in C plus 399 00:19:37.880 --> 00:19:39.400 plus REE, which. 400 00:19:39.200 --> 00:19:43.200 Brings us to smart pointers. The modern C plus plus solution. 401 00:19:43.119 --> 00:19:46.640