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. Isn't this fun? As we're going through this series of lectures, we're kind of revealing the onion, revealing the abstraction layer, and we're explaining how really the system works.
Và chào mừng bạn quay trở lại. Điều này thực tế khá thú vị phải không? Khi chúng ta đi qua loạt các bài giảng này, chúng ta đang tước từng lớp vỏ, tiết lộ từng tầng trừu tượng, và chúng ta đang giải thích cách thức hệ thống thực sự hoạt động.
So now I understand how to play with memory, how to break wire, how to request it with a malloc, how to give it back in freed. Really cool.
Vậy nên bây giờ tôi hiểu cách tương tác với bộ nhớ, cách phá vỡ dây, cách yêu cầu nó bằng malloc, cách trả lại nó bằng free. Thực sự tuyệt vời.
But there's some more details to this. Let's actually take a reflection of where do things really live, really live. This is really neat. People have never seen this before.
Nhưng vẫn còn nhiều chi tiết khác nữa. Hãy để chúng ta thực sự phản ánh xem mọi thứ thực sự sống ở đâu. Điều này thực sự tuyệt diệu. Mọi người chưa bao giờ thấy điều này trước đây.
You don't know this on your own. If you just pick up C on your own, you can be part of, say, 100 years, but you wouldn't know the things unless you get told this.
Bạn không tự biết được điều này. Nếu bạn chỉ tự học C, bạn có thể là một phần của, nói cách khác, 100 năm, nhưng bạn sẽ không biết những điều này nếu không ai nói cho bạn.
If you read the book, it'd probably tell you, but people don't read the book. But if you just kind of pick it up on your own, you're not going to do it.
Nếu bạn đọc cuốn sách, nó có thể sẽ nói cho bạn, nhưng mọi người không đọc cuốn sách. Nhưng nếu bạn chỉ tự mà tìm hiểu, bạn sẽ không làm được.
Don't forget global variables, first of all. Let's just summarize. When you make a structural declaration, that just declares a new type, a structure. That doesn't make any space for it.
Trước hết, đừng quên biến toàn cục. Hãy tóm tắt lại. Khi bạn khai báo một cấu trúc, nó chỉ khai báo một kiểu mới, một cấu trúc. Nó không tạo không gian cho nó.
That's just kind of a, here's a new type I'm going to use. But when you make a variable declaration, that actually does preserve memory. So that first one doesn't.
Nó chỉ là, đây là một kiểu mới mà tôi sẽ sử dụng. Nhưng khi bạn khai báo một biến, nó thực sự sẽ dành bộ nhớ. Cái đầu tiên thì không.
The second one does reserve memory. So far, we've talked about several ways to allocate memory for data. You can have a local variable, int i; struck Node list.
Cái thứ hai thì có cấp phát bộ nhớ. Cho đến nay, chúng ta đã nói về vài cách để cấp phát bộ nhớ cho dữ liệu. Bạn có thể có một biến cục bộ, int i; struct Node list.
That's the Node 2 fields value. And next, character star string. That's the space for the pointer, but not for the string itself. Int ar of n.
Đó là Node với 2 trường giá trị. Và tiếp theo, char star string. Đó là không gian cho con trỏ, nhưng không phải cho chuỗi kí tự nó. Int ar of n.
There's n integers. Got that. Or dynamically. Pointer equals struct Node star.
Có n số nguyên. Hiểu rồi. Hoặc động. Pointer equals struct Node star.
Malloc. Size of struct Node times n. That's n Nodes in a row. It's an array of Nodes rather than a linked list.
Malloc. Kích thước của struct Node nhân n. Đó là n Nodes liên tiếp. Nó là một mảng các Nodes thay vì một danh sách liên kết.
There's an array of those Nodes. That's pretty cool. The struct Nodes, I should say. There's one more place.
Có một mảng các Nodes đó. Khá hay đấy. Các struct Nodes, tôi nên nói như vậy. Còn một nơi nữa.
One way is a local variable. The second is this malloc-y thing. You don't even know where they live yet. I'll tell you that in a couple of slides.
Một cách là một biến cục bộ. Cách thứ hai là cái malloc này. Bạn thậm chí không biết chúng sống ở đâu. Tôi sẽ cho bạn biết điều đó trong vài slide tới.
And then finally, you can have a global variable. If I say int global, int myGlobal here, above main, so main is your top-level procedure, always.
Và cuối cùng, bạn có thể có một biến toàn cục. Nếu tôi viết int global, int myGlobal ở đây, trên main, vì vậy main là thủ tục cấp cao nhất của bạn, luôn luôn.
Always in C. But if I put myGlobal above main, it's now in the global namespace. You now have access to myGlobal everywhere.
Luôn luôn trong C. Nhưng nếu tôi đặt myGlobal trên main, nó nằm trong không gian tên toàn cục. Bây giờ bạn có thể truy cập myGlobal ở mọi nơi.
Any subroutine, including main or sub or foo, has access to read and write myGlobal. That's pretty cool.
Bất kỳ subroutine nào, bao gồm main hay sub hay foo, đều có thể đọc và ghi myGlobal. Điều đó khá tuyệt.
So if you need to have some value that's going to be shared, rather than passing it here, just this thing that's there, just out there — now, don't overuse it — you can obviously write the worst code in the world by having a billion globals.
Vì vậy, nếu bạn cần có một giá trị nào đó sẽ được chia sẻ, thay vì truyền nó ở đây, chỉ cái thứ đó ở đó, nằm ngoài — bây giờ, đừng lạm dụng nó — bạn rõ ràng có thể viết đoạn code tệ nhất thế giới bằng cách có một tỷ biến toàn cục.
But if you have some constant like a big table or something, you can use that without having so gross code, although it probably is better to pass things around.
Nhưng nếu bạn có một hằng số nào đó như một bảng lớn hoặc cái gì đó, bạn có thể dùng nó mà không cần code quá tệ, mặc dù có lẽ tốt hơn là truyền mọi thứ xung quanh.
But you can still, small programs, use globals sparingly. Use them sparingly, and you'll be fine. Has global scope. So now let's use some words.
Nhưng bạn vẫn có thể, với các chương trình nhỏ, dùng biến toàn cục một cách tiết chế. Dùng chúng một cách tiết chế, và bạn sẽ ổn. Có phạm vi toàn cục. Vậy bây giờ hãy dùng một số từ.
Use your words. C has three pools of memory. Remember, I had these local guys, I had this malloc guy, I had this global guy. Turns out that they live in three different places.
Dùng từ của bạn. C có ba vùng bộ nhớ. Nhớ lại, tôi có những biến cục bộ, tôi có cái malloc này, tôi có cái biến toàn cục này. Hóa ra chúng nằm ở ba nơi khác nhau.
The first one, static storage. That's the global space. It's static. Static means it doesn't — dynamic.
Cái đầu tiên, bộ nhớ tĩnh. Đó là không gian toàn cục. Nó là tĩnh. Tĩnh có nghĩa là nó không — động.
It's not dynamic. It means it's frozen. It doesn't mean you can't change it, but it means you can't change the size of it. You can still change the values inside.
Nó không phải động. Nó có nghĩa là nó được đóng băng. Điều đó không có nghĩa là bạn không thể thay đổi nó, nhưng có nghĩa là bạn không thể thay đổi kích thước của nó. Bạn vẫn có thể thay đổi các giá trị bên trong.
Like, myGlobal can be read and written to, but it lives in the static. So global variables live there. It's permanent, and there for the whole program. So it's not going to grow.
Ví dụ, myGlobal có thể được đọc và ghi, nhưng nó nằm trong vùng tĩnh. Vì vậy, các biến toàn cục nằm ở đó. Nó là vĩnh viễn và dành cho toàn bộ chương trình. Vì vậy nó sẽ không phát triển.
So static doesn't move. The stack is where your local values are. You might have heard the stack. Stack overflow, you've ever heard?
Vì vậy vùng tĩnh không di chuyển. Stack là nơi chứa các giá trị cục bộ của bạn. Bạn có thể đã nghe nói về stack. Stack overflow, bạn đã nghe bao giờ chưa?
Oh, maybe. Let me find something on stack overflow. Now you know stack overflow. We'll talk about why the stacks overflow.
À, có thể. Để tôi tìm kiếm thứ gì đó trên stack overflow. Bây giờ bạn đã biết stack overflow rồi. Chúng ta sẽ nói về lý do tại sao stack bị tràn.
But you've got a stack. Local variable storage parameters, return addresses — all these things are in the stack. And the heap is where your malloc goes. So dynamic stuff is the heap.
Nhưng bạn có một stack. Lưu trữ biến cục bộ, các tham số, địa chỉ trả về — tất cả những thứ này đều nằm trong stack. Và heap là nơi malloc của bạn đi. Vì vậy các thứ động được lưu trong heap.
I need to apologize in the basis of all computer scientists because the stack, the name stack, is the same as, 62NB's, a stack data structure.
Tôi cần xin lỗi thay cho tất cả các nhà khoa học máy tính vì stack, cái tên stack, cũng giống như một cấu trúc dữ liệu stack của 62NB.
And in fact, they operate very much the same way. So they're the same. Kind of the idea of the stack in memory and what a stack is, same thing.
Và thực tế, chúng hoạt động rất giống nhau. Vì vậy chúng là giống nhau. Ý tưởng về stack trong bộ nhớ và stack là gì, cũng là điều đó.
The heap is not the same as the heap data structure. So I apologize on the basis of all computer scientists who went before me, because it's a terrible name.
Heap thì không giống cấu trúc dữ liệu heap. Vì vậy tôi xin lỗi thay cho tất cả các nhà khoa học máy tính đứng trước tôi, vì nó là một cái tên kinh khủng.
The heap is not what a heap is. It's not stored. It's not somehow represented using a heap. It's not.
Heap không phải là những gì một heap là. Nó không được lưu trữ. Nó không được đại diện bằng cách nào đó sử dụng một heap. Nó không phải.
A heap is just a heap of memory. Don't think of the heap, oh, it must be stored like a heap structure. It's not. Stack is stored like a stack.
Heap chỉ là một đống bộ nhớ. Đừng nghĩ đến heap, ôi, nó phải được lưu trữ giống như một cấu trúc heap. Nó không phải. Stack được lưu trữ giống như một stack.
Operates like a stack. The heap does not. C, really fluid C, requires you to know what those three things are.
Hoạt động giống như một stack. Heap thì không. C, thực sự C dòng chảy, yêu cầu bạn biết ba thứ đó là gì.
This is why I think teaching C to CS1 students to intro programmers is a terrible idea.
Đây là lý do tại sao tôi nghĩ việc dạy C cho sinh viên CS1 để giới thiệu dạy lập trình C cho học sinh CS1, những người mới bắt đầu, là một ý tưởng tồi tệ.
It's just too much to learn about how the machine works and how the code works, how to debug. Too much. Easier language. Python, block-based language, something else.
Có quá nhiều thứ phải học về cách máy hoạt động, cách mã hoạt động, cách gỡ lỗi. Quá nhiều. Ngôn ngữ dễ hơn. Python, ngôn ngữ dựa trên khối, hay cái gì khác.
But don't teach in C initially. Third language is fine. Now you know how to program, but now you're learning how to program well. So here's a picture.
Nhưng đừng dạy C từ đầu. Ngôn ngữ thứ ba thì được. Bây giờ bạn biết cách lập trình, nhưng lúc này bạn đang học cách lập trình tốt. Vậy đây là một bức tranh.
The address space contains four regions. This is pretty cool. I love this picture. Finally, "ahh," revealing the — open the hood.
Không gian địa chỉ chứa bốn vùng. Cái này khá tuyệt vời. Tôi yêu thích bức tranh này. Cuối cùng, "aaa," tiết lộ — mở nắp máy ra.
There's a light shining out of this. The stack — local variables, remember? It starts at the top. Remember.
Có một tia sáng phát ra từ đây. Stack — biến cục bộ, nhớ chứ? Nó bắt đầu từ trên cùng. Nhớ lại.
Roughly, you have access to 30 to a machine, 2 to the 32, 0 to 2 to the 32, 32 minus 1. Bytes that you can read and write, for now.
Đại khái, bạn có quyền truy cập từ 2 mũ 30 đến máy, 2 mũ 32, 0 đến 2 mũ 32 trừ 1. Byte mà bạn có thể đọc và ghi, hiện tại.
Stacks float to the top and grows down. Jroop. As you have more things, as you increase the stack, it's going to grow down towards 0.
Stack nổi lên trên cùng và phát triển xuống dưới. Jroop. Khi bạn có nhiều thứ hơn, khi bạn tăng stack, nó sẽ phát triển xuống về phía 0.
The heap grows up towards this middle space. Static data is locked in. You know what the size of it is. It's locked in.
Heap phát triển lên về phía khoảng không gian giữa này. Dữ liệu tĩnh bị khóa cố định. Bạn biết kích thước của nó là bao nhiêu. Nó bị khóa cố định.
And in fact, the code — when you run a program, if I run foo, I run some program I've run, Hello World, the code for that gets loaded into memory as well.
Và thực tế, đoạn code — khi bạn chạy một chương trình, nếu tôi chạy foo, tôi chạy một chương trình mà tôi đã chạy, Hello World, đoạn code cho cái đó được tải vào bộ nhớ.
So that memory footprint contains all the code; all the static space you have, all those globals; any heap you've requested, probably nothing initially; and then whatever stack has initially, probably the main information here.
Vì vậy bộ nhớ đó chứa tất cả code; tất cả không gian tĩnh bạn có, tất cả những biến toàn cục đó; bất kỳ heap bạn đã yêu cầu, có thể không có gì ban đầu; và sau đó bất kỳ stack nào ban đầu, có thể là thông tin main ở đây.
Maybe the arguments passed in are up here. Why do we like this model?
Có thể các đối số truyền vào ở đây. Tại sao chúng ta thích mô hình này?
Well, it's nice, because if I had a program that had a lot of stack — had a lot of stack here, but little heap. Can you think of an example like that?
Vâng, nó tốt, bởi vì nếu tôi có một chương trình có nhiều stack — có nhiều stack ở đây, nhưng heap ít. Bạn có thể nghĩ ra một ví dụ như vậy không?
What might it be? Well, no heap means I never called malloc. A lot of stack means maybe a really long recursive. Maybe a runaway recursion.
Điều đó có thể là gì? Thì không có heap có nghĩa là tôi chưa bao giờ gọi malloc. Rất nhiều stack có nghĩa là có thể là một hàm đệ quy rất sâu. Có thể là đệ quy vô tưởng tượng.
Maybe a big fractal, or maybe I'm doing factorial of some huge number. Calls this, calls this, calls this, because those local variables, all those function calls, grow the stack.
Có thể là một fractal lớn, hoặc có thể tôi đang tính giai thừa của một số rất lớn. Gọi cái này, gọi cái này, gọi cái này, vì những biến cục bộ đó, tất cả những lệnh gọi hàm đó, làm cho stack tăng lên.
We'll talk about this. We're going to explain that a little bit more in a couple slides. How about heap? Can you think of something where the heap grows up, and almost no stack?
Chúng ta sẽ nói về điều này. Chúng ta sẽ giải thích điều đó chi tiết hơn một chút trong vài slide tiếp theo. Còn heap thì sao? Bạn có thể nghĩ ra điều gì đó mà heap phát triển lên, và hầu như không có stack?
Well, no function calls, so stack is going to grow, really. No arrays up there. No temporary variables that I've used in main, so the stack is pretty small.
Không có lệnh gọi hàm, nên stack sẽ phát triển rất nhiều. Không có mảng ở đó. Không có biến tạm thời mà tôi đã dùng trong main, nên stack khá nhỏ.
And I have — the first line is a massive call to malloc. Jroop. Now the heap will grow up high.
Và tôi có — dòng đầu tiên là một lệnh gọi malloc khổng lồ. Jroop. Bây giờ heap sẽ phát triển lên cao.
Do you know what program would allow you to have almost direct control of malloc? Photoshop. I want a new document. I want it 1,000,000 pixels by 1,000,000 pixels.
Bạn có biết chương trình nào cho phép bạn có kiểm soát hầu như trực tiếp đối với malloc không? Photoshop. Tôi muốn một tài liệu mới. Tôi muốn nó 1.000.000 pixel x 1.000.000 pixel.
1,000 by 1,000. That's 1,000,000 pixels. And now it has to grab it somewhere, dynamically. Grabs it from the heap.
1.000 x 1.000. Đó là 1.000.000 pixel. Và bây giờ nó phải lấy nó ở đâu đó, động. Lấy nó từ heap.
Another difference between the heap and stack is ar square brackets. That's nice, except that you can't — if I say ar of a million, what if I don't have room for 1,000,000?
Một khác biệt khác giữa heap và stack là dấu ngoặc vuông ar. Điều đó không tệ, ngoại trừ việc bạn không thể — nếu tôi nói ar của một triệu, điều gì sẽ xảy ra nếu tôi không có chỗ cho 1.000.000?
It'll crash. But if I ask it through malloc, what will malloc return? Null. So you can now have code that is resilient to memory failure if you used malloc versus using arrays.
Nó sẽ bị lỗi. Nhưng nếu tôi yêu cầu nó thông qua malloc, malloc sẽ trả về cái gì? Null. Vì vậy bây giờ bạn có thể có code có khả năng chịu đựng lỗi bộ nhớ nếu bạn sử dụng malloc thay vì sử dụng mảng.
We'll talk about more, but that's kind of an example. Like a razor, really fast. I get it really fast. Malloc might take a bit longer.
Chúng ta sẽ nói thêm, nhưng đó chỉ là một ví dụ. Giống như một lưỡi dao, thực sự nhanh. Tôi lấy nó thực sự nhanh. Malloc có thể mất một chút thời gian hơn.
I'll get to this in a moment as well. But malloc has the ability to tell you if it can't get it for you.
Tôi sẽ quay lại vấn đề này ngay sau. Nhưng malloc có khả năng cho bạn biết nếu nó không thể cấp cho bạn.
Whether you're array, if you want to make 1,000,000 array, maybe there's no room at all. Maybe you've heaped a lot, and now there's no room here.
Dù bạn dùng mảng, nếu bạn muốn tạo mảng 1.000.000 phần tử, có thể là không có chỗ trống nào cả. Có thể bạn đã sử dụng heap rất nhiều, và bây giờ không còn chỗ ở đây.
But it would crash if you say local variable, open square bracket, 1,000,000. It can't get it. Crash. There's no way to catch it.
Nhưng nó sẽ crash nếu bạn nói biến cục bộ, dấu ngoặc vuông mở, 1.000.000. Nó không thể cấp được. Crash. Không có cách nào để bắt được nó.
There's no way to save it. Codes at the bottom, static data, heap, and the stack. Important. But for now, don't worry about how somebody prevents them from overcrossing each other.
Không có cách nào để cứu được nó. Mã ở phía dưới, dữ liệu tĩnh, heap, và stack. Quan trọng. Nhưng hiện tại, đừng lo lắng về cách ai đó ngăn chặn chúng từ việc chồng chéo lên nhau.
So somehow that's prevented. The OS will handle it. Take 162 to learn all about it. So where are they allocated?
Vì vậy, bằng cách nào đó điều đó được ngăn chặn. Hệ điều hành sẽ xử lý nó. Hãy học 162 để tìm hiểu tất cả về nó. Vậy chúng được cấp phát ở đâu?
I kind of said before. If they're declared outside of procedure, meaning outside of all procedures, myGlobal, they're in the static area. If they're local, they're on the stack.
Tôi đã nói về điều đó trước đây. Nếu chúng được khai báo bên ngoài thủ tục, tức là bên ngoài tất cả các thủ tục, myGlobal, chúng sẽ nằm trong vùng tĩnh. Nếu chúng là biến cục bộ, chúng sẽ nằm trên stack.
If they are in malloc, they're on the heap. I said this before. And by the way, malloc is a procedure. Now, let's talk about what happens there.
Nếu chúng được sử dụng malloc, chúng sẽ nằm trên heap. Tôi đã nói điều này trước đây. Nhân tiện, malloc là một thủ tục. Bây giờ, hãy nói về điều gì xảy ra ở đó.
Freed when the procedure returns, which means, wait. So foo calls bar, and now I get some local temporary space. When bar goes away, it's actually freed now.
Được giải phóng khi thủ tục trả về, tức là, chờ đã. Vậy foo gọi bar, và bây giờ tôi có một số không gian tạm thời cục bộ. Khi bar biến mất, nó thực sự được giải phóng ngay bây giờ.
All that stuff that bar had, all those local variables that bar had, all those arrays that bar had — they're not malloc calls, but arrays — they go away when bar returns.
Tất cả những thứ mà bar có, tất cả các biến cục bộ mà bar có, tất cả các mảng mà bar có — chúng không phải là các lệnh gọi malloc, mà là các mảng — chúng biến mất khi bar trả về.
So that's actually kind of cool, and may manage the procedure as well. Here's your stack. Let's go a little deeper on the stack. So the stack frame includes the return address.
Vậy điều đó thực sự khá hay, và có thể quản lý thủ tục cũng vậy. Đây là ngăn xếp của bạn. Hãy đi sâu hơn một chút về ngăn xếp. Vậy khung ngăn xếp bao gồm địa chỉ trả về.
So how to go back to the previous guy? Important. Any parameters you have — and space for any local variables. So if you're ever, like, foo calls bar, calls baz.
Vậy làm thế nào để quay lại với người trước? Điều quan trọng. Bất kỳ tham số nào bạn có — và không gian cho bất kỳ biến cục bộ nào. Vậy nếu bạn có, chẳng hạn, foo gọi bar, gọi baz.
You ever wonder, how does it know where to come back to? It's the stack. That's how it does it. The other key thing is, the stack is a contiguous block of memory.
Bạn có bao giờ tự hỏi, nó biết quay về đâu không? Đó là stack. Đó là cách nó hoạt động. Điều then chốt khác là, stack là một khối bộ nhớ liên tiếp.
You'll see that malloc can actually be all over the place. It can be here and there and there, and that's going to be a problem. But the stack is always contiguous.
Bạn sẽ thấy rằng malloc thực sự có thể nằm ở khắp nơi. Nó có thể ở đây, ở đó và ở đó, và điều đó sẽ là một vấn đề. Nhưng stack luôn liên tiếp.
It grows like a stack. Unlike a stack that grows down, normally a stack grows up. When you think of it, the stack is growing down.
Nó phát triển giống như một stack. Không giống một stack phát triển xuống, thông thường một stack phát triển lên. Khi bạn nghĩ về nó, stack đang phát triển xuống.
When a procedure ends, the stack frame is tossed off. So it frees it dynamically. Pretty cool. So let's actually take a look at this.
Khi một thủ tục kết thúc, khung stack bị loại bỏ. Vì vậy nó giải phóng nó một cách động. Thực sự rất hay. Vậy hãy để tôi thực sự xem xét cái này.
Let's make a little animation. So I'm in main. Got some space for main. Some local stuff is going on in main.
Chúng ta hãy tạo một animation nhỏ. Vậy tôi đang ở trong main. Có không gian cho main. Có vài thứ cục bộ đang diễn ra trong main.
I'm happy. I call a of 0. I've got to know where to come back to. So I got to somehow set up.
Tôi vui vẻ. Tôi gọi a(0). Tôi phải biết nơi quay lại. Vậy tôi phải thiết lập điều gì đó.
I have to somehow set up a structure where I need to know when a returns, how to come back to me. So I have to store the line after a(0), the line right here.
Tôi phải thiết lập một cấu trúc nào đó nơi tôi cần biết khi a trả về, làm sao để quay lại tôi. Vậy tôi phải lưu trữ dòng sau a(0), dòng ngay tại đây.
This is the key thing right there.
Đây là điều then chốt ngay đó.
That address in the program needs to be stored somewhere. So when a comes back, I reload. That's where I'm going to start from. Someone's got to remember that, and it's the stack.
Địa chỉ đó trong chương trình cần được lưu ở đâu đó. Vì vậy khi a quay về, tôi nạp lại. Đó là nơi tôi sẽ bắt đầu từ. Ai đó phải ghi nhớ điều đó, và đó là stack.
That's the key.
Đó là chìa khóa.
So now, I call a. That's the bottom of the stack pointer. I'm going to now make a function call. So I'm going to grow the stack.
Vì vậy bây giờ, tôi gọi a. Đó là đáy của con trỏ stack. Tôi sắp thực hiện một lệnh gọi hàm. Vì vậy tôi sẽ mở rộng stack.
I'm going to store my return address, and any temporary — I'm going to pass at any parameters. Here we go. I've now grown the stack, and now that's where a is.
Tôi sẽ lưu địa chỉ trả về của tôi, và bất kỳ giá trị tạm thời — Tôi sẽ truyền bất kỳ tham số. Nào. Tôi đã mở rộng stack, và bây giờ đó là nơi a nằm.
So now main and I are alive, and the stack now has both of those active. And so any temporary variables that are a are in that area. And that's the blue.
Vì vậy bây giờ main và tôi đều còn sống, và stack bây giờ có cả hai cái đó đang hoạt động. Và bất kỳ biến tạm thời nào của a đều nằm trong vùng đó. Và đó là phần màu xanh.
I try to color-code them the same so you can kind of see the same. Now, a is going to call b, so I better grow the stack. Move the stack pointer down.
Tôi cố gắng tô màu chúng giống nhau để bạn có thể thấy được điều tương tự. Bây giờ, a sẽ gọi b, vì vậy tôi phải mở rộng stack. Di chuyển con trỏ stack xuống.
That's really fast. To do this, I'd basically take a stack pointer internally — I'll tell you, when we learn about assembly, you'll learn about this — I just move the stack pointer down.
Điều đó thực sự nhanh. Để làm điều này, về cơ bản tôi sẽ lấy con trỏ stack bên trong — Tôi sẽ nói cho bạn, khi chúng ta tìm hiểu về assembly, bạn sẽ tìm hiểu về điều này — Tôi chỉ di chuyển con trỏ stack xuống.
It's really fast. To grow the stack is very, very fast. And to shrink the stack, just move the stack pointer up. Pretty easy.
Nó thực sự nhanh. Mở rộng stack là rất, rất nhanh. Và để thu nhỏ stack, chỉ cần di chuyển con trỏ stack lên. Khá đơn giản.
All this is now the room for b's local variables and the parameters. The n has got to be there somewhere. All those things are there.
Tất cả những cái này bây giờ là chỗ cho các biến cục bộ của b và các tham số. n phải ở đâu đó. Tất cả những thứ đó đều có.
It turns out that the n actually gets passed as a register. Too much detail now. But some space for b to work with, and to know how to get back to a.
Hóa ra n thực tế được truyền vào dưới dạng một thanh ghi. Quá chi tiết rồi. Nhưng có một số chỗ để b làm việc, và để biết cách quay lại a.
Then I go down to c. Same thing. All we're doing is the same thing. Then I go down to d.
Rồi tôi đi xuống c. Cũng vậy. Tất cả những gì chúng ta làm là điều tương tự. Rồi tôi đi xuống d.
Now here's the key. I'm going to now invert this. Now d returns. So what should happen?
Bây giờ đây là điểm chính. Tôi sắp đảo ngược cái này. Bây giờ d quay trở lại. Vậy điều gì nên xảy ra?
Did I go back into the code and erase it? Grab my eraser and erase the memory, make it all 0's. No. The answer is always no.
Tôi có quay lại code và xóa nó không? Lấy cục tẩy và xóa bỏ bộ nhớ, làm cho tất cả đều bằng 0. Không. Câu trả lời luôn là không.
I don't have time. No time, no time. It's almost like, no time, no time. It's like my joke about ain't no free lunch.
Tôi không có thời gian. Không có thời gian, không có thời gian. Nó gần giống như, không có thời gian, không có thời gian. Nó giống như trò đùa của tôi về không có bữa ăn miễn phí.
No time, no time. I'm too busy. I can't erase it.
Không có thời gian, không có thời gian. Tôi quá bận rộn. Tôi không thể xóa nó được.
So you're going to notice, interestingly, that if d had some secret value, secret value password to the whole world's computer system equals Bosco, and you typed it in the local variable.
Vì vậy các bạn sẽ nhận thấy, điều thú vị là, nếu d có một giá trị bí mật, giá trị bí mật mật khẩu để truy cập hệ thống máy tính của toàn thế giới bằng Bosco, và bạn đã nhập nó vào biến cục bộ.
So it lived in here. Somewhere in here was Bosco. And now, that was when the stack point was there. And now I returned from d, and I go back.
Vì vậy nó nằm ở đây. Ở đâu đó trong đây là Bosco. Và lúc đó, đó là khi con trỏ ngăn xếp ở đây. Và bây giờ tôi trở về từ d, và tôi quay lại.
Well, guess what? Like the PowerPoint shows you, it's still there. Even though I don't have access to it — officially, I can't be accessing anything past the stack — Bosco is still in memory.
Vâng, bạn đoán xem? Như PowerPoint cho bạn thấy, nó vẫn còn ở đây. Mặc dù tôi không có quyền truy cập vào nó — theo lý thuyết, tôi không thể truy cập bất cứ gì vượt quá ngăn xếp — Bosco vẫn còn trong bộ nhớ.
Interesting. You should check that out. It's really fun. So now, let me clear that up.
Thú vị đấy. Bạn nên kiểm tra điều đó. Nó thực sự vui. Vậy nên bây giờ hãy để tôi làm rõ điều đó.
Now C returns. I just moved the stack pointer up. And immediately, that space doesn't — zeroed out, but is not space I can use anymore.
Bây giờ C trả về. Tôi vừa di chuyển con trỏ ngăn xếp lên. Và ngay lập tức, không gian đó không — được xóa sạch, nhưng không phải là không gian tôi có thể sử dụng nữa.
Now b returns and a returns, and I'm still in main doing my stuff. Isn't that cool? So that's basically how that — notice that was like a stack.
Bây giờ b trả về và a trả về, và tôi vẫn đang ở trong main làm việc của tôi. Có phải là tuyệt vời không? Vậy đó cơ bản là cách đó — lưu ý rằng nó giống như một ngăn xếp.
Stack grows down, stack grows up when you function called, and you returned d to c to b to a, back into main.
Ngăn xếp phát triển xuống, ngăn xếp phát triển lên khi hàm được gọi, và bạn trả về d cho c cho b cho a, quay trở lại main.
Now we're living here, and now main is working with all those local variables, doing all the right things. It's pretty cool. And it knew how to get back, because you had the stack.
Bây giờ chúng ta sống ở đây, và bây giờ main đang làm việc với tất cả các biến cục bộ đó, làm tất cả những việc đúng. Thật là tuyệt vời. Và nó biết cách quay trở lại, vì bạn có ngăn xếp.
Again, you learned this all when you learned about assembly. You need to know how to come back.
Lại nữa, bạn đã học tất cả những điều này khi bạn học về assembly. Bạn cần biết cách quay lại.
All that's stored in the stack, all the local spaces there, and you free it by moving the stack down and moving the stack up. Easy. See you at the next lecture.
Tất cả những thứ đó được lưu trữ trong stack, tất cả các không gian cục bộ ở đó, và bạn giải phóng nó bằng cách di chuyển stack xuống và di chuyển stack lên. Dễ thôi. Hẹn gặp bạn ở bài giảng tiếp theo.
Đă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.