Giấy phép mở: được chia sẻ lại khi ghi công tác giả, được chỉnh sửa, được dùng thương mại.
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 sự trở lại. Thật vui phải không? Khi chúng ta đang xem qua loạt bài giảng này, chúng tôi đang tiết lộ một loại hành tây, tiết lộ lớp trừu tượng và chúng tôi đang giải thích hệ thống thực sự hoạt động như thế nào.
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 là giờ tôi hiểu cách chơi với trí nhớ, cách phá dây, làm thế nào để yêu cầu nó bằng malloc, làm thế nào để trả lại nó trong freed. Thật 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 một số chi tiết nữa. Chúng ta hãy thực sự suy ngẫm về nơi thực sự làm mọi thứ sống, sống thực sự. Thật tuyệt vời. 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 thể tự mình biết điều này được. Nếu bạn chỉ tự mình chọn C, bạn có thể là một phần của, chẳng hạn, 100 năm, nhưng bạn sẽ không biết được điều này nếu không được kể cho nghe.
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, có lẽ nó sẽ cho bạn biết, nhưng mọi người không đọc cuốn sách đó. Nhưng nếu bạn chỉ tự mình nhặt nó lên, bạn sẽ không làm điều đó đâu.
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 . Chúng ta hãy tóm tắt lại nhé. Khi bạn thực hiện một tuyên bố cấu trúc, chỉ khai báo một kiểu mới, một cấu trúc. Như thế không có chỗ 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.
Đó chỉ là một kiểu, đây là kiểu mới mà tôi sẽ sử dụng. Nhưng khi bạn khai báo biến, thực sự có tác dụng bảo tồn trí nhớ. Vậy thì 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.
Thứ hai là giữ lại bộ nhớ. Cho đến nay, chúng ta đã nói về một số cách để phân bổ bộ nhớ cho dữ liệu. Bạn có thể có một biến cục bộ, int i; danh sách Node bị đánh dấu.
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à giá trị trường Node 2. Và tiếp theo là chuỗi ký tự ngôi sao. Đó là không gian cho con trỏ, nhưng không phải đối với bản thân sợi dây. Số nguyên dương của n.
There's n integers. Got that. Or dynamically. Pointer equals struct Node star.
Có n số nguyên. Tôi hiểu rồi. Hoặc động. Con trỏ bằng 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. Có n nút liên tiếp. Đây là một mảng các nút chứ không phải là một danh sách được 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 Nút đó. Thật tuyệt vời. Tôi nên nói là struct Nodes. Vẫn 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 khác là sử dụng biến cục bộ. Thứ hai là thứ malloc này. Bạn thậm chí còn chưa biết họ sống ở đâu. Tôi sẽ cho bạn biết điều đó trong vài slide nữa.
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 nói int global, int myGlobal ở đây, phía trên main, vì vậy, thủ tục chính luôn là thủ tục cấp cao nhất của bạ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, bây giờ 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ỳ chương trình con nào, bao gồm cả chương trình con chính hoặc chương trình con phụ hoặc chương trình con foo, có quyền đọc và ghi myGlobal. Thật tuyệt vời.
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 số giá trị đó là sẽ được chia sẻ, thay vì truyền nó đến đây, chỉ có thứ này ở đó, ngay ngoài kia — bây giờ, đừng lạm dụng nó — rõ ràng là bạn có thể viết mã tệ nhất thế giới bằng cách có một tỷ toàn cầu.
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 số hằng số như một cái bàn lớn hay thứ gì đó, bạn có thể sử dụng nó mà không cần phải có mã quá thô, mặc dù có lẽ tốt hơn là nên truyền tay nhau.
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ể, các chương trình nhỏ, sử dụng biến toàn cục một cách tiết kiệm. Hãy sử dụng chúng một cách tiết kiệm và bạn sẽ ổn thôi. Có phạm vi toàn cầu. Bây giờ chúng ta hãy sử 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.
Hãy sử dụng lời nói của bạn. C có ba vùng nhớ. Hãy nhớ rằng, tôi đã có những anh chàng địa phương, tôi đã có anh chàng malloc, Tôi đã có anh chàng toàn cầu này. Hóa ra họ sống ở 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.
Đầu tiên là lưu trữ tĩnh. Đó là không gian toàn cầu. Nó tĩnh. Tĩnh có nghĩa là 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 động. Nghĩa là nó bị đông lạnh. Không có nghĩa là bạn không thể thay đổi nó, nhưng điều đó 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.
Giống như, myGlobal có thể được đọc và ghi vào, nhưng nó tồn tại trong trạng thái tĩnh. Vì vậy, biến toàn cục tồn tại ở đó. Nó là vĩnh viễn và tồn tại trong toàn bộ chương trình. Vì thế 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ậy tĩnh điện không chuyển động. Ngăn xếp là nơi lưu trữ các giá trị cục bộ của bạn. Có thể bạn đã nghe đến cụm từ này. Stack Overflow, bạn đã từng nghe đến 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 thông tin trên stack overflow nhé. Bây giờ bạn đã biết về stack overflow. Chúng ta sẽ nói về lý do tại sao ngăn xếp 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 chồng. Tham số lưu trữ biến cục bộ , địa chỉ trả về — tất cả những thứ này đều có trong ngăn xếp. Và heap là nơi malloc của bạn lưu trữ. Vậy thì những thứ động là một đống.
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 phải xin lỗi trên cơ sở của tất cả các nhà khoa học máy tính bởi vì chồng, tên chồng, giống như 62NB, một cấu trúc dữ liệu ngăn xếp.
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à trên thực tế, chúng hoạt động theo cùng một cách. Vậy thì chúng giống nhau. Loại ý tưởng về ngăn xếp trong bộ nhớ và stack là gì thì cũng giống nhau.
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 không giống với cấu trúc dữ liệu heap. Vì vậy, tôi xin lỗi trên cơ sở tất cả các nhà khoa học máy tính đã đi trước tôi, vì đó là một cái tên khủng khiếp.
The heap is not what a heap is. It's not stored. It's not somehow represented using a heap. It's not.
Đống không phải là thứ mà một đống là. Nó không được lưu trữ. Nó không được biểu diễn bằng cách nào đó bằng một đống. Không phải vậy.
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.
Một đống chỉ là một đống ký ức. Đừng nghĩ đến đống đổ nát, ôi, nó phải thế được lưu trữ như một cấu trúc đống. Không phải vậy. Stack được lưu trữ như một ngăn xếp.
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 ngăn xếp. Đống thì không. C, C thực sự lưu động, đòi hỏi bạn phải 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ĩ rằng việc dạy học sinh từ C đến CS1 cần phải giới thiệu lập trình viên 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.
Quá nhiều thứ để tìm hiểu về cách thức hoạt động của máy và cách thức hoạt động của mã , cách gỡ lỗi. Quá nhiều. Ngôn ngữ dễ hiểu hơn. Python, ngôn ngữ theo 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 bằng C ngay từ đầu. Ngôn ngữ thứ ba thì tốt. Bây giờ bạn đã biết cách lập trình, nhưng bây giờ bạn học cách lập trình tốt. Đây là một bức ảnh.
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ỉ bao gồm bốn vùng. Thật tuyệt vời. Tôi thích bức ảnh này. Cuối cùng, "ahh," để lộ — mở mui xe.
There's a light shining out of this. The stack — local variables, remember? It starts at the top. Remember.
Có một ánh sáng đang chiếu ra từ đây. Stack - biến cục bộ, bạn còn nhớ không? Nó bắt đầu từ phía trên. Nhớ.
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ó thể tiếp cận 30 đến một máy, 2 đến 32, 0 đến 2 đến 32, 32 trừ 1. Hiện tại, bạn có thể đọc và ghi các byte này .
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.
Các chồng nổi lên trên và phát triển xuống dưới. Thằng nhóc. Khi bạn có nhiều thứ hơn, khi bạn tăng ngăn xếp, nó sẽ giảm dần về mức 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.
Đống phân này lớn dần về phía khoảng không ở giữa. Dữ liệu tĩnh bị khóa. Bạn biết kích thước của nó là bao nhiêu. Nó bị khóa rồi.
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ế là, mã này — khi bạn chạy một chương trình, nếu tôi chạy foo, Tôi chạy một số chương trình tôi đã chạy, Hello World, mã cho chương trình đó cũng đượ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, dấu chân bộ nhớ đó chứa toàn bộ mã; tất cả không gian tĩnh bạn có, tất cả các toàn cục đó; bất kỳ đống nào bạn đã yêu cầu, có thể ban đầu không có gì; và sau đó bất kể ngăn xếp nào ban đầu có, có lẽ là thông tin chính đây.
Maybe the arguments passed in are up here. Why do we like this model?
Có lẽ những lập luận được đưa ra ở đây. Tại sao chúng tôi 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, thật tuyệt, bởi vì nếu tôi có một chương trình đã có rất nhiều chồng — có rất nhiều chồng ở đây, nhưng ít đống. Bạn có thể nghĩ ra ví dụ nào như thế 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.
Đó có thể là gì? Vâng, không có đống nghĩa là tôi chưa bao giờ gọi malloc. Nhiều ngăn xếp có thể có nghĩa là đệ quy thực sự dài. Có lẽ là một sự đệ quy mất kiểm soát.
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ể là tôi tính giai thừa của một số rất lớn. Gọi thế này, gọi thế này, gọi thế này, bởi vì những biến cục bộ đó, tất cả những lệnh gọi hàm đó, tăng số lượng ngăn xếp.
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 tôi sẽ giải thích thêm một chút trong vài slide. Còn đống thì sao? Bạn có thể nghĩ ra điều gì đó mà đống rác lớn lên không, và hầu như không có chồng?
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.
Vâng, không có lệnh gọi hàm nào cả, vì vậy ngăn xếp sẽ thực sự lớn hơn. Không có mảng nào ở đó cả. Không có biến tạm thời nào mà tôi đã sử dụng trong main, vì vậy ngăn xếp 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 lớn đến malloc. Thằng nhóc. Bây giờ đống phân sẽ cao dần.
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 sẽ cho phép Bạn có thể kiểm soát gần như trực tiếp malloc? Phần mềm Photoshop. Tôi muốn một tài liệu mới. Tôi muốn nó có kích thước 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. Tức là 1.000.000 pixel. Và bây giờ nó phải lấy vật đó ở đâu đó một cách năng động. Lấy nó từ đống đó.
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 sự khác biệt nữa giữa heap và stack là dấu ngoặc vuông. Thật tuyệt, ngoại trừ việc bạn không thể — nếu tôi nói ar của một triệu, thì sao nếu tôi không đủ 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ẽ sụp đổ. Nhưng nếu tôi hỏi thông qua malloc thì malloc sẽ trả về kết quả gì? Vô giá trị. Vì vậy, bây giờ bạn có thể có mã có khả năng phục hồi sau lỗi bộ nhớ nếu bạn sử dụng malloc so với 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 về điều này, nhưng đó chỉ là một ví dụ. Giống như dao cạo, thực sự nhanh. Tôi hiểu rất nhanh. Malloc có thể mất nhiều thời gian hơn một chút.
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ẽ nói đến điều này ngay sau đây. Nhưng malloc có khả năng cho bạn biết nếu nó không thể giúp 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.
Cho dù bạn là mảng, nếu bạn muốn tạo 1.000.000 mảng, có thể là không còn chỗ trống nào cả. Có thể bạn đã chất quá nhiều thứ và bây giờ không còn chỗ ở đây nữa.
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ẽ bị sập nếu bạn nói biến cục bộ, mở ngoặc vuông, 1.000.000. Nó không thể lấy được. Tai nạn. 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 để lưu nó. Mã ở phía dưới, dữ liệu tĩnh, heap và stack. Quan trọng. Nhưng bây giờ, đừng lo lắng về việc ai đó ngăn cản họ 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ý việc này. Dành 162 phút để tìm hiểu tất cả về nó. Vậy chúng được phân bổ ở đâ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 rồi. Nếu chúng được khai báo ngoài thủ tục, nghĩa là bên ngoài tất cả các thủ tục, myGlobal, chúng nằm trong vùng tĩnh. Nếu chúng là dữ liệu cục bộ, chúng sẽ được lưu trên ngăn xếp.
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 ở dạng malloc, chúng sẽ ở trên đống. Tôi đã nói điều này trước đây. Và nhân tiện, malloc là một thủ tục. Bây giờ, chúng ta hãy nói về những 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ề, nghĩa là hãy đợi. Vì vậy, foo gọi bar và bây giờ tôi có được một số không gian tạm thời cục bộ. Khi thanh này biến mất, thực ra nó đã được giải phóng.
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à thanh đó có, tất cả những biến cục bộ mà thanh đó đã có, tất cả các mảng mà thanh đó có — chúng không phải là các lệnh gọi malloc, nhưng mảng — chúng sẽ biến mất khi thanh bar quay trở lại.
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ì vậy, điều đó thực sự khá thú vị và có thể quản lý quy trình cũng như vậy. Đây là chồng bài của bạn. Chúng ta hãy đi sâu hơn một chút vào ngăn xếp này. Vì 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 sao để quay lại với anh chàng trước đây? Quan trọng. Bất kỳ thông số nào bạn có — và không gian cho bất kỳ biến cục bộ nào. Vì vậy, nếu bạn từng gọi foo là bar, hãy 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, làm sao nó biết được nơi nào cần quay trở lại không? Đó là chồng sách. Đó là cách nó thực hiện. Điều quan trọng khác là, ngăn xếp là một khối bộ nhớ liền kề.
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ể xuất hiện ở khắp mọi nơi. Nó có thể ở đây, ở đó và ở đó, và đó sẽ là một vấn đề. Nhưng ngăn xếp luôn luôn liền kề.
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ó lớn lên như một chồng. Không giống như một chồng cây mọc hướng xuống, thông thường một chồng cây sẽ mọc hướng lên. Khi bạn nghĩ về điều đó, chồng dữ liệu đang giảm dần.
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 ngăn xếp sẽ bị xóa bỏ. Vì vậy, nó giải phóng năng động. Thật tuyệt. Vậy chúng ta hãy cùng xem xét vấn đề 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 hình ảnh động nhỏ nhé. Vậy là tôi ở vị trí chính. Có đủ chỗ cho món chính. Một số hoạt động địa phương đang diễn ra ở khu vực chính.
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 lắm. Tôi gọi a bằng 0. Tôi phải biết nơi nào để quay về. Vì vậy, tôi phải tìm cách thiết lập.
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 bằng cách nào đó nơi tôi cần biết khi nào trả lại, làm sao để quay lại với tôi. Vì vậy, tôi phải lưu trữ dòng sau a(0), dòng bên phải đây.
This is the key thing right there.
Đây chính là điều quan trọng nhất.
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 phải được lưu trữ ở đâu đó. Vì vậy, khi quay lại, tôi sẽ tải lại. Đó chính là nơi tôi sẽ bắt đầu. Ai đó phải nhớ điều đó, và đó chính là chồng giấy.
That's the key.
Đó chính 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ậy bây giờ, tôi gọi a. Đó là đáy của con trỏ ngăn xếp. Bây giờ tôi sẽ thực hiện lệnh gọi hàm. Vì vậy, tôi sẽ mở rộng ngăn xếp.
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 trữ địa chỉ trả lại của mình và bất kỳ thông tin tạm thời nào — Tôi sẽ truyền bất kỳ tham số nào. Chúng ta bắt đầu thôi. Bây giờ tôi đã phát triển ngăn xếp và đó chính là vị trí của a.
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ậy bây giờ main và tôi còn sống, và stack bây giờ có cả hai chức năng đó đang hoạt động. Và do đó bất kỳ biến tạm thời nào cũng nằm trong vùng đó. Và đó là 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 mã hóa màu chúng giống nhau để bạn có thể thấy điều tương tự. Bây giờ, a sẽ gọi b, vì vậy tôi nên mở rộng ngăn xếp. Di chuyển con trỏ ngăn xếp xuống dưới.
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.
Nhanh thật đấy. Để làm được điều này, về cơ bản tôi sẽ sử dụng một con trỏ ngăn xếp bên trong — Tôi sẽ cho bạn biết, khi chúng ta học về lắp ráp, bạn sẽ học về điều này — Tôi chỉ di chuyển con trỏ ngăn xếp xuống dưới.
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.
Thật sự là nhanh lắm. Việc tăng trưởng stack diễn ra rất, rất nhanh. Và để thu nhỏ ngăn xếp, chỉ cần di chuyển con trỏ ngăn xếp lên trên. Khá dễ.
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 điều này bây giờ là chỗ cho các biến cục bộ của b và các thông số. Chữ n phải có ở đâ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.
Thực ra, n thực sự được truyền như một thanh ghi. Quá nhiều chi tiết rồi. Nhưng vẫn còn một số không gian để 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.
Sau đó tôi đi xuống c. Cũng vậy thôi. Tất cả những gì chúng ta đang làm đều giống nhau. Sau đó 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?
Và đây là chìa khóa. Bây giờ tôi sẽ đảo ngược điều này. Bây giờ d trả về. Vậy thì điều gì sẽ 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 mã và xóa nó không? Hãy lấy cục tẩy của tôi và xóa hết ký ức đi, biến tất cả thành số 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. Giống như là không có thời gian, không có thời gian vậy. Giống như câu nói đùa của tôi rằng không có bữa trưa nào là 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 bận quá. 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, bạn sẽ nhận thấy, thật thú vị, rằng nếu d có một số giá trị bí mật, giá trị bí mật mật khẩu cho toàn bộ hệ thống máy tính của 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ậy là nó sống ở đây. Ở đâu đó trong này có Bosco. Và đó chính là lúc điểm xếp chồng xuất hiện. Và bây giờ tôi đã trở về từ d, và tôi quay trở 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, đoán xem nào? Giống như PowerPoint cho bạn thấy, nó vẫn ở đó. Mặc dù tôi không có quyền truy cập vào nó một cách chính thức, Tôi không thể truy cập bất cứ thứ gì ngoài ngăn xếp — Bosco vẫn còn trong ký ức.
Interesting. You should check that out. It's really fun. So now, let me clear that up.
Hấp dẫn. Bạn nên kiểm tra điều đó. Thật sự rất vui. 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 quay trở lại. Tôi vừa di chuyển con trỏ ngăn xếp lên trên. Và ngay lập tức, không gian đó không còn nữa, nhưng không còn chỗ trống nào 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 chủ yếu là làm việc của mình. Thật tuyệt phải không? Về cơ bản thì nó như thế này — hãy chú ý xem nó giống như một chồng vậy.
Stack grows down, stack grows up when you function called, and you returned d to c to b to a, back into main.
Stack tăng lên khi bạn gọi hàm, và bạn trả lại d đến c đến b đến a, 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 đang sống ở đây, và bây giờ chính đang làm việc với tất cả các biến cục bộ đó, làm mọi điều đúng đắn. Thật tuyệt vời. Và nó biết cách quay lại vì bạn đã có chồng.
Again, you learned this all when you learned about assembly. You need to know how to come back.
Một lần nữa, bạn đã học được tất cả những điều này khi học về lắp ráp. Bạn cần biết cách quay trở 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 gì được lưu trữ trong ngăn xếp, 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 ngăn xếp xuống và di chuyển chồng lên nhau. Dễ. Hẹn gặp lại các 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.