Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
PROFESSOR
And welcome back.
Chào mừng bạn quay lại.
This last segment, this last video, An Introduction to C, the goal is to figure out how to teach you the things that you probably will do if we didn't tell you in advance.
Phần cuối cùng này, video cuối cùng này, Giới thiệu về C, mục đích là để tìm ra cách dạy bạn những thứ mà bạn có thể sẽ làm nếu chúng tôi không nói cho bạn biết trước.
These are the common mistakes people make when working with memory or, dun-dun-dun, when memory goes bad. This is just a review slide. Why do we do pointers at all?
Đây là những sai lầm phổ biến mà mọi người mắc phải khi làm việc với bộ nhớ, hoặc, dùm dùm, khi bộ nhớ bị hỏng. Đây chỉ là slide ôn tập. Tại sao chúng ta phải dùng con trỏ?
Well, if I'm going to pass some value into a function, I don't want to pass all that data. It'd be a copy, because it's called by value. I want to pass a pointer.
Nếu tôi sắp truyền một giá trị vào một hàm, tôi không muốn truyền tất cả dữ liệu đó. Nó sẽ là một bản sao, vì nó được gọi theo giá trị. Tôi muốn truyền một con trỏ.
So you can have access to my structure here, my array or my big struct or something. What are the drawbacks? You've got to deal with these pointers.
Vì vậy bạn có thể có quyền truy cập vào cấu trúc của tôi ở đây, mảng của tôi hoặc struct lớn của tôi hoặc gì đó như thế. Các nhược điểm là gì? Bạn phải xử lý những con trỏ này.
You've got to deal with the fact that, when you make a malloc and free request, maybe you forget to do it. Maybe you're doing the wrong order.
Bạn phải xử lý thực tế là, khi bạn thực hiện yêu cầu malloc và free, có thể bạn quên làm. Có thể bạn làm theo thứ tự sai.
Maybe you move the pointer around and you don't do it. A lot of problems. So Denali Reference says, I make a pointer. I initialize a pointer.
Có thể bạn di chuyển con trỏ xung quanh và bạn không làm. Rất nhiều vấn đề. Vì vậy Denali Reference nói, tôi tạo một con trỏ. Tôi khởi tạo một con trỏ.
Then here is where I'm going to malloc and set it to it. But I start using it before I actually have set it to the right malloc value.
Rồi đây là nơi tôi sẽ malloc và gán nó cho nó. Nhưng tôi bắt đầu sử dụng nó trước khi tôi thực sự đã gán nó cho giá trị malloc đúng.
There's another mini-era of what happens when you start reading from this initialized array before you even write to it. So that's an issue.
Có một mini-era khác về những gì xảy ra khi bạn bắt đầu đọc từ mảng được khởi tạo này trước khi bạn thậm chí còn ghi vào nó. Vậy đó là một vấn đề.
Memory leak happens where you've reserved something from malloc, but then you never free it. So a tardy free says you forget to free it.
Rò rỉ bộ nhớ xảy ra khi bạn đã dành một cái gì đó từ malloc, nhưng sau đó bạn không bao giờ giải phóng nó. Vậy một lần giải phóng muộn có nghĩa là bạn quên giải phóng nó.
You can also lose the pointer, or you free it a little too late. Bad things can happen, so free at the right time.
Bạn cũng có thể mất con trỏ, hoặc bạn giải phóng nó hơi muộn. Những điều xấu có thể xảy ra, vì vậy hãy giải phóng đúng lúc.
This is the easiest case, writing off the end of an array. Here's foo. It makes 100. I'll use a little picture here.
Đây là trường hợp đơn giản nhất, ghi đè cuối của một mảng. Đây là foo. Nó tạo ra 100. Tôi sẽ sử dụng một hình vẽ nhỏ ở đây.
It makes a little array. I'll just write, that's my array. Isn't that a pretty array? And foo points to the beginning of int.
Nó tạo ra một mảng nhỏ. Tôi sẽ viết thôi, đó là mảng của tôi. Mảng đó có đẹp không? Và foo trỏ đến vị trí đầu tiên của int.
That's the 0 guy there. And at 0, up to — it's 100 elements, so 0 up to 99. Well, what does this loop say? 0 up to and including 100.
Đó là phần tử 0 ở đây. Và ở vị trí 0, lên đến — nó có 100 phần tử, nên từ 0 đến 99. Vòng lặp này nói cái gì? Từ 0 lên đến và bao gồm 100.
Wait. You mean you're going to write to this 100th element, 101st element at 100? You don't have access to that. You have access to 99.
Chờ đã. Bạn muốn nói là bạn sẽ ghi vào phần tử thứ 100, phần tử thứ 101 ở vị trí 100? Bạn không có quyền truy cập vào đó. Bạn có quyền truy cập đến 99.
So the problem is that what if you had another array? What if this were the beginning of another array this way? Well, then you have access to that data, some other malloc over here.
Vậy vấn đề là, nếu bạn có một mảng khác thì sao? Nếu đây là vị trí đầu tiên của một mảng khác như vậy? Vậy thì bạn có quyền truy cập vào dữ liệu đó, một lệnh malloc khác ở đây.
That's not an error to write to that from this program. But you don't know that. So here, you're setting to 0. So this had key value.
Không phải là lỗi khi ghi vào đó từ chương trình này. Nhưng bạn không biết điều đó. Vì vậy ở đây, bạn đang đặt thành 0. Vì vậy cái này có giá trị key.
You now write a 0 to that. And you don't find that error until much, much later, because only much later, years later, you actually visit that part.
Bây giờ bạn ghi 0 vào đó. Và bạn không phát hiện ra lỗi đó cho đến sau này, lâu sau, vì chỉ sau này, nhiều năm sau, bạn mới thực sự truy cập phần đó.
And you say, well, surely, that's never supposed to be 0. Now it's 0 because that simple little loop overrode it. Won't check it for you. So watch out for your limits of your array.
Và bạn nói, chắc chắn, nó không bao giờ được phép là 0. Bây giờ nó là 0 vì vòng lặp nhỏ đó đã ghi đè nó. Nó sẽ không kiểm tra cho bạn. Vì vậy hãy cẩn thận với giới hạn của mảng của bạn.
0 up to and including — less than. So the error is obviously the equal sign here. So make that a less than, and that'll work. So watch out.
0 cho đến và bao gồm — nhỏ hơn. Vậy lỗi rõ ràng là dấu bằng ở đây. Vậy thay nó bằng dấu nhỏ hơn, khi đó nó sẽ hoạt động. Vậy hãy cẩn thận.
Watch your bounce. This is a great example. You cannot return a pointer into a memory stack space. Here's this little guy.
Cẩn thận với ranh giới của bạn. Đây là một ví dụ tuyệt vời. Bạn không thể trả về một con trỏ từ không gian bộ nhớ stack. Đây là chàng trai nhỏ này.
Very simple. Here's this pointer function. It sets a little cute little y. It sets into 3 little y.
Rất đơn giản. Đây là hàm con trỏ này. Nó đặt một y nhỏ dễ thương. Nó đặt thành 3 y nhỏ.
Sets into 3, and returns a pointer to it. Well, you're not supposed to do that. Why? Here is the pointer stack address, and here's the content.
Đặt thành 3 và trả về một con trỏ tới nó. Chà, bạn không được phép làm điều đó. Tại sao? Đây là địa chỉ stack của con trỏ, và đây là nội dung.
The content Is going to contain the 3. Let's see. Hopefully, okay? So let's try it.
Nội dung sẽ chứa số 3. Hãy xem nào. Hy vọng là được. Vậy hãy thử nó.
Stack address equals pointer. While this is running, while that's running, this is what the world looks like. Main has its stack frame, and pointer has its stack frame.
Stack address bằng pointer. Trong khi cái này đang chạy, trong khi cái kia đang chạy, đây là cảnh thế giới trông như thế nào. Main có stack frame của nó, và pointer có stack frame của nó.
Everything's good. And int pointer was y, because y is a temporary variable, and so that y lives right in there. Everybody's happy. Everything's good.
Mọi thứ đều tốt. Và int pointer là y, vì y là một biến tạm thời, nên y đó sống ở ngay đó. Mọi người đều vui lòng. Mọi thứ đều tốt.
Everything's there, before the grasshoppers came back. Maybe catch fans of "A Bug's Life." Now when that returns at this equal sign, this is what the world looks like.
Mọi thứ đều ở đó, trước khi những chú châu chấu quay lại. Có thể để vui cho những fan của "A Bug's Life". Bây giờ khi hàm đó trả về ở dấu bằng này, đây là thế giới trông như thế nào.
There's no more — that stack frame is gone. It didn't erase it, didn't scrub it. But it's gone. Now really, there is a 3 in here, still.
Không còn — stack frame đó đã biến mất. Nó không xóa sạch, không tẩy sạch. Nhưng nó đã biến mất. Bây giờ thực sự, vẫn còn một 3 ở đây.
So stack address gets the address of that. I don't know what the address is. Who cares? Maybe this is at 1,000.
Vì vậy stack address nhận được địa chỉ của nó. Tôi không biết địa chỉ là gì. Ai quan tâm? Có thể cái này ở 1.000.
So it gets the 1,000. So stack address gets 1,000. So stack address points to that spot. Points to that spot.
Vì vậy nó nhận được 1.000. Vì vậy stack address nhận được 1.000. Vì vậy stack address trỏ đến vị trí đó. Trỏ đến vị trí đó.
So now, I then say content equals star stack address. If this is what — remember, I'm going to keep this guy here. That doesn't move. That's never going to move.
Vậy bây giờ, tôi nói content bằng star stack address. Nếu cái này là — nhớ là, tôi sẽ giữ cái này ở đây. Nó không di chuyển. Nó sẽ không bao giờ di chuyển.
That points to that spot where there was a 3 there. Now, content equals that. Follow the pointer and set it to content, and print it out. 3.
Nó trỏ đến vị trí đó, nơi có số 3. Bây giờ, content bằng cái đó. Theo con trỏ và gán nó vào content, rồi in nó ra. 3.
That's great. Wait. Do it again. Go grab it again.
Tuyệt vời. Chờ. Làm lại. Lấy nó ra lần nữa.
It prints garbage? Wait. What? Yeah.
Nó in ra rác? Chờ. Cái gì? Phải.
You know why? Because during this printf, that's what the world looked like. Printf is a function call. Functions have to make a stack frame.
Bạn biết tại sao không? Vì trong lúc printf này, đó là những gì mà thế giới trông như. Printf là một lệnh gọi hàm. Các hàm phải tạo một khung stack.
Who knows what internal material, internal local variables, what print that needs to do? But it needs something. So it clobbered over your 3 that you didn't have access to in the first place.
Ai biết được những vật liệu nội bộ, các biến cục bộ nội bộ, printf cần phải in cái gì? Nhưng nó cần điều gì đó. Vì vậy nó đã ghi đè lên 3 của bạn mà bạn không có quyền truy cập vào từ đầu.
But it looked good. For the first time, it printed out 3. But this printf itself clobbered the 3. It grabbed it.
Nhưng nó trông tốt. Lần đầu tiên, nó in ra 3. Nhưng chính printf này đã ghi đè lên 3. Nó đã lấy nó.
And then in the process of doing something, it actually clobbered over it. So it grabbed the 3 — kind of funny. This is the grab of the 3.
Và sau đó khi làm điều gì đó, nó thực sự đã ghi đè lên nó. Vì vậy nó lấy cái 3 — khá thú vị. Đây là quá trình lấy cái 3.
That was the find of 3. That was the factor of 3. Then printf clobbers it, puts this number there. So now, that number, it was a 3.
Đó là quá trình tìm kiếm 3. Đó là quá trình tính toán của 3. Sau đó printf ghi đè lên nó, đặt con số này vào đó. Vì vậy bây giờ, con số đó, nó là 3.
Now it says, whatever this number is. And the next time I go grab, I go, follow that pointer, I print out garbage. That make sense? So love this demo.
Bây giờ nó nói, con số này là bất kỳ cái gì. Và lần tiếp theo khi tôi đi lấy, tôi đi, theo con trỏ đó, tôi in ra rác. Hiểu chứ? Tôi yêu demo này.
Love this example of something that — how was that possible? I just followed the pointer twice in succession, and it's bad the second time? Yeah.
Thích ví dụ này về cái gì — làm sao mà điều đó có thể xảy ra? Tôi vừa follow pointer hai lần liên tiếp, và lần thứ hai nó lại bị sai? Đúng vậy.
Because printf clobbered it, because you weren't supposed to be there in the first place. You're not supposed to use something after free. Here's f, which is a pointer to a struct foo.
Vì printf đã làm hỏng nó, vì bạn không được phép ở đó ngay từ đầu. Bạn không được dùng một cái gì đó sau khi free. Đây là f, một pointer tới struct foo.
I malloc space for that. I'm all set there. And now I free it. That's great.
Tôi malloc không gian cho nó. Tôi làm xong ở đây. Và bây giờ tôi free nó. Tốt lắm.
But then the line after it, I'm going to access the a element from that, the a field from that. You can't do that. Once you've freed f, you have no access.
Nhưng rồi dòng tiếp theo, tôi lại truy cập phần tử a từ đó, trường a từ đó. Bạn không thể làm vậy. Khi đã giải phóng f, bạn không còn truy cập được nữa.
Now you're pointing to this guy. It's in there, but who knows if it got clobbered in there? It may work, but it may not work.
Bây giờ bạn đang trỏ tới cái này. Nó ở trong đó, nhưng ai biết được nó có bị ghi đè không? Nó có thể hoạt động, nhưng cũng có thể không.
Again, you don't know what's happening in that malloc space. It may give you an error. It may give you a segmentation fault. It may not check it at all.
Lại nữa, bạn không biết chuyện gì đang xảy ra trong vùng malloc đó. Nó có thể cho bạn một lỗi. Nó có thể cho bạn một lỗi segmentation fault. Nó có thể không kiểm tra gì cả.
All the things are open, and you don't want to have that happen. So don't follow, don't access. Once you've freed something, you had no access to it anymore.
Tất cả những điều đó đều mở ra, và bạn không muốn điều đó xảy ra. Vì vậy đừng theo, đừng truy cập. Khi đã giải phóng thứ gì đó, bạn không còn có quyền truy cập nó nữa.
Really important. And again, you might not find this out for hours later. And all of a sudden, wait, why does it crash? Well, because you kind of corrupted something.
Thực sự quan trọng. Và lại nữa, bạn có thể không phát hiện ra điều này cho đến vài giờ sau. Và bất ngờ, tại sao nó lại bị crash? Vâng, vì bạn đã gây hủy hoại cái gì đó.
You grabbed [INAUDIBLE] that's bad. Realloc can move the data. That's another thing we talked about. Realloc can reallocate a space.
Bạn lấy [INAUDIBLE] đó là xấu. Realloc có thể di chuyển dữ liệu. Đó là một điều khác mà chúng ta đã nói về. Realloc có thể cấp phát lại không gian.
So here's malloc. It makes 10 structures. Here, here, and there. There's my f, and f points to that.
Vậy đây là malloc. Nó tạo 10 cấu trúc. Ở đây, ở đây, và ở đó. Đó là f của tôi, và f trỏ đến cái đó.
There's my f, points to that. And look. This says, struct foo *g. That's another pointer, g, which points to the same thing.
Đó là f của tôi, trỏ đến cái đó. Và nhìn này. Cái này nói, struct foo *g. Đó là một con trỏ khác, g, trỏ đến cùng một thứ.
That's called sharing. They both own the same thing. But now, this is a nice call to realloc. In the process of realloc, it might just grow.
Đó được gọi là chia sẻ. Cả hai cùng sở hữu một thứ. Nhưng bây giờ, đây là một lệnh realloc tốt. Trong quá trình realloc, nó có thể chỉ phát triển.
It is 20 now. It might just grow it. If so, then everything works. Then they both share in the space.
Hiện tại nó dài 20. Nó có thể chỉ phát triển nó. Nếu vậy, thì mọi thứ hoạt động. Thì cả hai đều chia sẻ không gian đó.
F and g, the space for that, those structures are still there. Except what if realloc didn't have room, there wasn't room here? So I'd have to move it.
F và g, không gian cho đó, những cấu trúc đó vẫn ở đó. Ngoại trừ nếu realloc không có chỗ, không có chỗ ở đây? Vậy tôi phải di chuyển nó.
I had to pick up the house and move it. So now, this is 20 long. And now f is reassigned to there. But what happens?
Tôi phải bốc dỡ ngôi nhà và di chuyển nó. Vậy bây giờ, nó dài 20. Và bây giờ f được gán lại vào đó. Nhưng chuyện gì xảy ra?
G is what we call a stale pointer. G points to the old guy. And now you're going to access g? Bad, bad.
G là cái chúng ta gọi là con trỏ cũ. G trỏ tới cái cũ. Và bây giờ bạn sẽ truy cập g? Tồi, tồi.
Could be bad. Could be fine, could be bad. You don't know. Again, all these things are weird, and don't do that.
Có thể tồi. Có thể tốt, cũng có thể tồi. Bạn không biết. Lại nữa, tất cả những thứ này đều kỳ quặc, đừng làm thế.
Don't free the wrong stuff. Here's a malloc for, again, the 10 structures. And now I'm going to say, f plus, plus. So here's my malloc here, guy.
Đừng giải phóng những thứ sai. Đây là một malloc cho, lại nữa, 10 cấu trúc. Và bây giờ tôi sẽ nói, f cộng, cộng. Vậy đây là malloc của tôi, bạn.
Here's my f. Points right to the front of it. That's the 0-th element. And now, f plus, plus.
Đây là f của tôi. Trỏ ngay tới phía trước của nó. Đó là phần tử thứ 0. Và bây giờ, f cộng, cộng.
F now points to the first element. And now I free it. Add. Free has a list.
Bây giờ f trỏ tới phần tử thứ nhất. Và bây giờ tôi giải phóng nó. Thêm. Free có một danh sách.
What does free take? An address.
Free lấy cái gì? Một địa chỉ.
So free has an address that malloc, and the process of doing malloc, internally in their bookkeeping — they keep track of all the mallocs ahead, which is like the pointer to the malloc returned.
Vì vậy free có một địa chỉ mà malloc trả về, và quá trình thực hiện malloc, bên trong trong hệ thống kế toán của chúng — chúng giữ theo dõi tất cả các malloc trước đây, như là con trỏ đến malloc đã trả về.
Return, return, return, return. Free gets one, and it doesn't match. I don't even know what free can do. So don't do that, because who knows what free would do.
Trả về, trả về, trả về, trả về. Free nhận một cái, và nó không khớp. Tôi thậm chí không biết free có thể làm gì. Vì vậy đừng làm điều đó, vì ai biết free sẽ làm gì.
Free could corrupt internal storage. It could erase things. Again, it could leave it like it looks like it works, but it actually doesn't work later. All these things are really hard to track down.
Free có thể làm hỏng bộ lưu trữ nội bộ. Nó có thể xóa những thứ. Lại nữa, nó có thể để lại trạng thái trông như nó hoạt động, nhưng thực tế nó không hoạt động sau đó. Tất cả những điều này thực sự rất khó để theo dõi.
Don't do that. Don't double free it, either. First line is a malloc, the second line is a free, and then you free it again. Free is only supposed to be done once, never twice.
Đừng làm vậy. Đừng double free nó nữa. Dòng đầu tiên là một malloc, dòng thứ hai là một free, và sau đó bạn free nó lại. Free chỉ được phép thực hiện một lần, không bao giờ được hai lần.
So that's a problem, too. You don't even know what's going to happen again. You don't know what would happen as a result to that. Here's one where you lose the initial pointer.
Vậy đó cũng là một vấn đề. Bạn thậm chí không biết điều gì sẽ xảy ra lại. Bạn không biết kết quả sẽ như thế nào từ điều đó. Đây là một trường hợp bạn mất con trỏ ban đầu.
Again, a memory leak. I call void. I've got this pointer. That's a global guy out here, plk.
Lại nữa, một rò rỉ bộ nhớ. Tôi gọi void. Tôi có cái con trỏ này. Đó là biến toàn cục ở đây, plk.
I assign it, which is great. I can assign it to malloc. That's fine. That's a total value.
Tôi gán nó, điều đó rất tốt. Tôi có thể gán nó thành malloc. Điều đó không sao. Đó là một giá trị hoàn toàn.
That's valid. But now, I plk plus, plus. But I didn't know that outside of it.
Đó là hợp lệ. Nhưng bây giờ, tôi plk cộng, cộng. Nhưng tôi không biết điều đó bên ngoài.
So I now no longer, outside, have whatever plk — I can't say free plk anymore, because I moved it over. I didn't know that outside. I called you library.
Vì vậy bây giờ ở bên ngoài, tôi không còn có bất kỳ cái gì plk — Tôi không thể nói free plk nữa, vì tôi đã chuyển nó qua. Tôi không biết điều đó bên ngoài. Tôi đã gọi thư viện bạn.
Your library moved my plk. And all of a sudden, my plk isn't pointing to the front anymore, and it's not the head anymore. I can't do it.
Thư viện của bạn đã chuyển plk của tôi. Và đột nhiên, plk của tôi không còn chỉ đến phía trước nữa, và nó không còn là head nữa. Tôi không thể làm được.
Always keep a head pointer to the front of that. Same idea. Don't do that. It could be a memory leak because, again, we don't know what's going to happen to plk again.
Luôn giữ một con trỏ head chỉ đến phía trước của nó. Ý tưởng tương tự. Đừng làm như vậy. Nó có thể là một rò rỉ bộ nhớ vì, một lần nữa, chúng ta không biết điều gì sẽ xảy ra với plk nữa.
Shooh, boy, I wish there were something. I wish there were something that would help me with this. There is. Valgrind is a wonderful piece of software that will check for these things.
Ôi trời, tôi ước rằng có thứ gì đó. Tôi ước rằng có thứ gì đó giúp tôi với điều này. Có đó. Valgrind là một phần mềm tuyệt vời sẽ kiểm tra những điều này.
It will check for memory leaks, misuse of free, writing of the end of arrays.
Nó sẽ kiểm tra rò rỉ bộ nhớ, lạm dụng free, ghi dữ liệu ở cuối các mảng.
Valgrind is really good about looking at your static code and deciding what's it going to do and what are some of the problems it's going to have. Really great.
Valgrind thực sự tốt trong việc xem xét mã tĩnh của bạn và quyết định nó sẽ làm gì và những vấn đề nào nó sẽ gặp phải. Thực sự tuyệt vời.
It's essential for debugging C code. Please go check that out. I believe it's available in the labs. In conclusion — whew.
Nó rất cần thiết cho việc gỡ lỗi mã C. Vui lòng kiểm tra nó. Tôi tin rằng nó có sẵn trong các phòng thí nghiệm. Tóm lại — phew.
That's the end. C has three memory management segments to which to allocate data. Static. That's the globals.
Đó là kết thúc. C có ba đoạn quản lý bộ nhớ để cấp phát dữ liệu. Tĩnh. Đó là biến toàn cục.
Don't worry about it. Stack. Again, you don't worry about it. The operating system grows it and shrinks it automatically.
Đừng lo lắng về nó. Ngăn xếp. Một lần nữa, bạn không cần lo lắng về nó. Hệ điều hành sẽ mở rộng và thu nhỏ nó tự động.
The heap. Again, mostly don't worry about it, except for making sure when you malloc, you always free exactly the guy you malloc.
Heap. Lại nữa, phần lớn bạn không cần lo lắng, ngoại trừ chắc chắn rằng khi bạn malloc, bạn luôn phải free đúng cái bạn malloc.
And don't forget not to do it, and don't do it twice, and don't move your pointer. All those things you can do wrong. Don't do that.
Và đừng quên không làm nó, cũng đừng làm hai lần, và đừng di chuyển con trỏ của bạn. Tất cả những thứ đó bạn có thể làm sai. Đừng làm như vậy.
And heap problems are the biggest source of problems in C. So good luck with your C programming. We'll see you at the next module. Take care.
Và vấn đề heap là nguồn gốc lớn nhất của những vấn đề trong C. Vậy chúc bạn lập trình C thành công. Chúng ta sẽ gặp bạn ở module tiếp theo. Giữ gìn sức khỏe.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.