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. Now let's actually get real, and explain to you how to actually work with real memory. So this is what makes C different from Java and Python.
Và chào mừng quay lại. Bây giờ hãy để chúng tôi thực sự nói rõ cho bạn cách làm việc với bộ nhớ thực tế. Đây là điều làm cho C khác với Java và Python.
You're going to have control of how much memory you get, and how much you want, and how to release it and do all those things. Let's talk about it today.
Bạn sẽ có quyền kiểm soát bạn nhận được bao nhiêu bộ nhớ, bạn muốn bao nhiêu, và cách giải phóng nó và làm tất cả những điều đó. Hôm nay hãy nói về nó.
So we learned that C has this sizeof function, which gives the size and bytes of the thing you pass in, that's great, and that can be a type or it can be a variable, which is nice.
Vì vậy chúng tôi đã biết rằng C có hàm sizeof này, nó cho kích thước tính theo byte của thứ bạn truyền vào, điều đó rất tốt, và nó có thể là một kiểu dữ liệu hoặc nó có thể là một biến, điều này rất hay.
And back in the day, ints were 16 bits. So you could ask, size of int 30 years ago, 40 years ago, 30 maybe.
Và ngày xưa, các số nguyên là 16 bit. Vì vậy bạn có thể hỏi, kích thước của int 30 năm trước, 40 năm trước, có thể là 30.
And it would say 2, and now it'll say 4, and maybe now it'll say 8 soon. This is again, why I use int types, I keep saying that.
Và nó sẽ nói 2, và bây giờ nó sẽ nói 4, và có thể ngay bây giờ nó sẽ nói 8 sớm thôi. Đây là lý do tại sao tôi lại sử dụng kiểu int, tôi vẫn nói như vậy.
So sizeof knows the type of array. If I have int. ar of 3, size of ar, it says 12. That's three integers, and so 3 times 4 is 12.
Vì vậy sizeof biết kiểu của mảng. Nếu tôi có int ar của 3, size of ar, nó nói 12. Đó là ba số nguyên, và vì vậy 3 nhân 4 bằng 12.
As well as integers that you know at runtime. So here is Ar(n), which is a dynamic number, or it's a function that returns 3.
Cũng như các số nguyên mà bạn biết tại thời gian chạy. Vì vậy ở đây là Ar(n), đó là một số động tính, hoặc nó là một hàm trả về 3.
And you say int.ar of some function whose value, which evaluates to 3, and ar of that, which is 3.
Và bạn nói int ar của một hàm nào đó có giá trị, được tính bằng 3, và ar của điều đó, là 3.
Do it again, it'll still say 12 for the size of the number of bytes you've got. So, this is the first time we've ever talked about in this class.
Làm lại, nó vẫn sẽ nói 12 cho kích thước của con số byte mà bạn có. Vì vậy, đây là lần đầu tiên chúng tôi từng nói về điều này trong lớp học này.
The way you ask for memory dynamically, aside from the array, there's an array, we talked about that before, is using malloc.
Cách bạn yêu cầu bộ nhớ động ngoài mảng, có một mảng, chúng ta đã nói về điều đó trước đây, là sử dụng malloc.
And we'll talk about what the difference between malloc and an array is soon. So here's the first time you've ever done this.
Và chúng ta sẽ nói về sự khác biệt giữa malloc và một mảng sớm thôi. Vậy đây là lần đầu tiên bạn từng làm điều này.
So I say, pointer, I've got a pointer to an array of integers. I'll say array of integers. I declare it malloc.
Vậy tôi nói, con trỏ, tôi có một con trỏ đến một mảng các số nguyên. Tôi sẽ nói mảng các số nguyên. Tôi khai báo nó malloc.
So malloc is a function that takes in the number of bytes you want and returns a pointer to uninitialized space. So it's not initialized. Remember, C never initializes these for you.
Vậy malloc là một hàm nhận vào số byte bạn muốn và trả về một con trỏ đến không gian chưa được khởi tạo. Vậy nó không được khởi tạo. Hãy nhớ, C không bao giờ khởi tạo những thứ này cho bạn.
And it also returns it as a void*, because it doesn't know what it wants in general. It's going to return a void*.
Và nó cũng trả về nó dưới dạng void*, vì nó không biết nó muốn cái gì nói chung. Nó sẽ trả về một void*.
Remember, void* a pointer to a generic space, to the generic array, you have to cast that.
Hãy nhớ, void* là một con trỏ đến không gian chung, đến mảng chung, bạn phải ép kiểu cái đó.
So you have to say, if pointer is declared an int*, so int* pointer, you have to then cast that with this. And that tells the system, don't worry about it.
Vì vậy bạn phải nói, nếu pointer được khai báo là int*, vì vậy int* pointer, bạn phải ép kiểu cái đó với cái này. Và điều đó nói với hệ thống, đừng lo lắng về nó.
I know malloc returns a void*, but I want to cast it as an int*, so that the equal sign matches up. The right side equals the int*, the left side equals an int*.
Tôi biết malloc trả về một void*, nhưng tôi muốn ép kiểu nó thành int*, để dấu bằng khớp với nhau. Vế phải bằng int*, vế trái bằng int*.
So that's good. Okay? That's all it is. It's called a a typecast.
Vì vậy điều đó là tốt. Được không? Đó là tất cả những gì nó là. Nó được gọi là một ép kiểu.
We've kind of seen that. That's the first time we've seen that, actually. Malloc, however, is almost never reserved. Why would you malloc just to get one integer?
Chúng ta đã thấy điều đó rồi. Thực ra, đó là lần đầu tiên chúng ta thấy. Tuy nhiên, malloc hầu như không bao giờ được đặt trước. Tại sao bạn lại malloc chỉ để lấy một integer?
If you want to just make an int, make fu. Int.fu, there's an integer. You probably want an array, if you want a lot of them. So this is the way it typically is done.
Nếu bạn chỉ muốn tạo một int, hãy tạo fu. Int.fu, đó là một integer. Nếu bạn muốn nhiều cái, bạn có thể sẽ muốn một mảng. Vì vậy, đây là cách nó thường được làm.
Ptr=int* malloc, and you have n times size of that. So that says, I want an array of n integers, and pointer points to that array.
Ptr=int* malloc, và bạn có n lần size của điều đó. Vì vậy điều đó nói, tôi muốn một mảng n integers, và con trỏ trỏ đến mảng đó.
Now, it's not a static array with the square brackets. But it is an array nevertheless, we still call them arrays. So, once malloc is called, the memory location contains garbage, you know this, right?
Bây giờ, nó không phải là một mảng tĩnh với các dấu ngoặc vuông. Nhưng nó vẫn là một mảng, chúng ta vẫn gọi chúng là mảng. Vì vậy, khi malloc được gọi, vị trí bộ nhớ chứa rác, bạn biết điều này rồi, phải không?
You know that we never initialize things. We never reset things. C is too fast. So that's going to be an uninitialized set of — if it's three guys, three integers, it's three garbage integers.
Bạn biết rằng chúng ta không bao giờ khởi tạo các thứ. Chúng ta không bao giờ đặt lại các thứ. C quá nhanh. Vì vậy đó sẽ là một tập hợp không được khởi tạo — ba chàng trai, ba số nguyên, đó là ba số nguyên rác.
Just 12 bytes of nothing. Who knows what they are. The key is, when you're done with that space, whatever pointer, whatever that malloc returned, that's a value.
Chỉ 12 byte không có gì cả. Ai biết chúng là gì. Điều quan trọng là, khi bạn dùng xong không gian đó, con trỏ bất kỳ, bất kỳ cái mà malloc trả về, đó là một giá trị.
That's a pointer to the beginning of that space. You eventually need to free it. And there's a kind of a contract, there's a contract between malloc and you.
Đó là một con trỏ đến đầu của không gian đó. Cuối cùng bạn cần phải giải phóng nó. Và có một loại hợp đồng, có một hợp đồng giữa malloc và bạn.
It's almost like — I don't know, it's almost like going to the Godfather and asking for a favor.
Nó gần như là — tôi không biết, nó gần như là đi tới Godfather và yêu cầu một điều kỳ diệu.
Godfather, I would like some memory from you.
Godfather, tôi muốn xin một số bộ nhớ từ bạn.
Some day, and the day may never come, I may call upon you to do a favor for me.
Một ngày nào đó, và ngày hôm đó có thể không bao giờ đến, tôi có thể sẽ yêu cầu bạn làm một điều kỳ diệu cho tôi.
But until that day, I will give you some malloc, under the contract, and you must free it when you are done. That's my Godfather imitation.
Nhưng cho đến ngày hôm đó, tôi sẽ cấp cho bạn một số malloc, theo hợp đồng, và bạn phải giải phóng nó khi bạn hoàn tất. Đó là bắt chước Godfather của tôi.
So even though the program is going to free it when you're done, don't do that. Don't let the program free it for you. Make sure you free it yourself.
Vì vậy, mặc dù chương trình sẽ giải phóng nó khi bạn hoàn tất, đừng làm vậy. Đừng để chương trình giải phóng nó cho bạn. Hãy chắc chắn rằng bạn tự giải phóng nó.
Why? Because you never know when your main becomes a subroutine. They say, oh, this is pretty cool thing. Let me wrap it in a subroutine, and over here.
Tại sao? Vì bạn không bao giờ biết khi nào main của bạn trở thành một subroutine. Họ nói, ồ, cái này khá tuyệt vời. Để tôi đóng gói nó trong một subroutine, và ở đây.
By the way, but you never freed it. So now, this main never frees it. We call this a memory leak, and all of a sudden that's a subroutine.
Dù sao, nhưng bạn chưa bao giờ giải phóng nó. Vì vậy, main này không bao giờ giải phóng nó. Chúng ta gọi đây là rò rỉ bộ nhớ, và đột nhiên nó trở thành một subroutine.
Now you got to call it many times, and all of a sudden all that memory you asked for, it just gets spilled. It doesn't get spilled, it gets leaked.
Bây giờ bạn phải gọi nó nhiều lần, và đột nhiên tất cả bộ nhớ mà bạn yêu cầu, nó chỉ tràn ra. Nó không tràn ra, nó bị rò rỉ.
It gets leaked. It's a leak of memory, and that's really bad. So you don't want that. So definitely listen to the Godfather, and free it at the end.
Nó bị rò rỉ. Đó là rò rỉ bộ nhớ, và điều đó thực sự rất tệ. Vì vậy bạn không muốn điều đó. Vì vậy chắc chắn hãy nghe lời Godfather, và giải phóng nó ở cuối.
When you're all done, and there's a lot of details to this, you can't use it after your free. Once you're free, you're all done.
Khi bạn hoàn thành, và có rất nhiều chi tiết trong việc này, bạn không thể sử dụng nó sau khi free. Một khi bạn free, bạn đã hoàn thành.
So whatever malloc gives you, that pointer, you better pass that same pointer to free, someday, use it, use it, use it, then pass it to free, and then you can't use it after that.
Vì vậy, bất cứ con trỏ nào mà malloc cấp cho bạn, bạn phải truyền cùng con trỏ đó đến free, và sử dụng nó, sử dụng nó, sử dụng nó, rồi truyền nó đến free, và sau đó bạn không thể sử dụng nó nữa.
Again, important thing. So, here are some things that are going to bite you. We're going to see this a lot. Because I want to make sure you see all these things that'll bite you.
Lần nữa, điều này rất quan trọng. Vì vậy, đây là những điều sẽ gây rắc rối cho bạn. Chúng ta sẽ thấy rất nhiều. Vì tôi muốn chắc chắn rằng bạn thấy tất cả những điều này sẽ gây rắc rối cho bạn.
Because they will bite you. They bit me, they basically bite every beginning programmer. The following two things will cause an error. Freeing the same piece of memory twice.
Vì chúng sẽ gây rắc rối cho bạn. Chúng đã gây rắc rối cho tôi, chúng cơ bản gây rắc rối cho mọi lập trình viên mới vào nghề. Hai điều sau đây sẽ gây ra lỗi. Giải phóng cùng một phần bộ nhớ hai lần.
I told you that, once you free it once, you can't touch it again. It's out there. And it can be reused, maybe, so you can't free it twice.
Tôi đã nói với bạn rằng, khi bạn free nó một lần, bạn không thể chạm vào nó lần nữa. Nó nằm đó. Và nó có thể được tái sử dụng, có thể, nên bạn không thể free nó hai lần.
You also can't call free on something you didn't get back from malloc. So I got, here's a malloc. You can only call free on that guy, you can't free anything else.
Bạn cũng không thể gọi free trên thứ gì đó mà bạn không lấy được từ malloc. Vì vậy tôi có, đây là một malloc. Bạn chỉ có thể gọi free trên cái đó, bạn không thể free bất cứ thứ gì khác.
If you move the pointer, you can't call free on the new pointer. You have to call free on the exact address passed back from malloc. Okay?
Nếu bạn di chuyển con trỏ, bạn không thể gọi free trên con trỏ mới. Bạn phải gọi free trên địa chỉ chính xác được trả về từ malloc. Được không?
So kind of three things you can do wrong. If I told you malloc, and then free that guy eventually after you're done with it. Well, you were done with it.
Vì vậy cơ bản là ba điều bạn có thể làm sai. Nếu tôi nói với bạn malloc, và sau đó free cái đó sau khi bạn sử dụng xong nó. Vâng, bạn đã xong với nó.
But then you freed it twice, bad, or you called free, and then — on something that was not that. Or you didn't free it at all. A lot of ways you can mess up.
Nhưng rồi bạn giải phóng nó hai lần, điều xấu, hoặc bạn gọi free, rồi — trên cái gì không phải cái đó. Hoặc bạn không giải phóng nó lúc nào cả. Rất nhiều cách để bạn có thể làm sai.
And the runtime doesn't check for it. It doesn't check for this. C is too fast, C is too performance critical.
Và runtime không kiểm tra nó. Nó không kiểm tra cái này. C quá nhanh, C quá quan trọng về hiệu suất.
Doesn't do this, your code is going to be either left in an inconsistent state, because you've messed with the memory allocator somehow, and you won't find that bug until way later, which is bad.
Không làm cái này, code của bạn sẽ ở trong trạng thái không nhất quán, vì bạn đã làm hỏng bộ cấp phát bộ nhớ bằng cách nào đó, và bạn sẽ không tìm thấy lỗi đó cho đến rất lâu sau, điều xấu.
You're running a server. All of a sudden, why does the server crash?
Bạn đang chạy một máy chủ. Bất chợt, tại sao máy chủ lại bị crash?
Yeah, because you did some weird thing with malloc and free back then, and then eventually you paid for it later, really bad. Kind of like not brushing your teeth.
Vâng, vì bạn đã làm gì đó kỳ lạ với malloc và free lúc đó, và rồi sau này bạn phải trả giá cho nó, thật tệ hại. Giống như không đánh răng.
Brush your teeth, because years later, you'll pay for it. Trust me. I'm fine, the point is there. Turns out, okay, you malloc something.
Hãy đánh răng, vì sau nhiều năm, bạn sẽ phải trả giá. Tin tôi đi. Tôi không sao, chỉ là ý tôi muốn nói. Hóa ra, được rồi, bạn malloc cái gì đó.
Big space. Okay. But interesting, what if I wanted to make it bigger, or smaller? Could I actually resize it?
Một vùng lớn. Được. Nhưng thú vị, nếu tôi muốn làm nó to hơn, hay nhỏ hơn thì sao? Tôi có thể thực sự thay đổi kích thước nó được không?
Sure! So it's called realloc. Realloc takes the pointer, the original pointer that malloc gave you. So I returned a guy from malloc as a pointer to that.
Được thôi! Vậy nó gọi là realloc. Realloc nhận vào con trỏ, con trỏ ban đầu mà malloc đã cấp cho bạn. Vì vậy tôi trả về một giá trị từ malloc dưới dạng con trỏ tới nó.
I could say, you know what? I wanted more now. I want twice as much, or 5 times as much, or I want it smaller. I can call realloc, and that returns a new pointer.
Tôi có thể nói, bạn biết không? Bây giờ tôi cần nhiều hơn. Tôi muốn gấp đôi, hoặc gấp 5 lần, hoặc tôi muốn nó nhỏ hơn. Tôi có thể gọi realloc, và nó trả về một con trỏ mới.
Now, what I didn't tell you, this is the thing on the previous slide, malloc sometimes can't satisfy your request. I'd like 4 trillion billion. I'd like 1 billion integers.
Giờ, cái mà tôi chưa kể cho bạn, đây là thứ trên slide trước, malloc đôi khi không thể đáp ứng yêu cầu của bạn. Tôi muốn 4 tỷ tỷ. Tôi muốn 1 tỷ số nguyên.
I'd want some amount of space, and maybe the space is run up. Maybe all the space you had access to is full. Malloc has to have a failure mode.
Tôi muốn một lượng không gian nào đó, và có thể không gian đã hết. Có thể tất cả không gian bạn có quyền truy cập đều đã đầy. Malloc phải có một chế độ xử lý lỗi.
Let's think about it, what's its failure mode? Before, I told you the Unix level, when you return a 0, it's success, everything else is a failure. But here, what is this sentinel for memory?
Hãy nghĩ xem, chế độ lỗi của nó là gì? Trước đó, tôi đã kể cho bạn ở mức Unix, khi bạn trả về 0, đó là thành công, mọi thứ khác là lỗi. Nhưng ở đây, sentinel cho bộ nhớ là gì?
What's the single value that malloc could return that we know could never be a valid value that malloc can return? 0, null.
Giá trị duy nhất nào mà malloc có thể trả về mà chúng ta biết không bao giờ có thể là một giá trị hợp lệ mà malloc có thể trả về? 0, null.
So every call to malloc had better have the next line, you check to see if the pointer ==0.
Vì vậy mỗi lệnh gọi malloc phải có dòng tiếp theo, bạn kiểm tra xem con trỏ ==0.
Now one of the early mistakes people make is check if pointer = 0, well, pointer = 0 assigns pointer to 0, and now all of a sudden you've lost — you've spilled, you've leaked the memory that malloc gave you.
Bây giờ một trong những lỗi sớm mà mọi người mắc phải là kiểm tra nếu con trỏ = 0, à, con trỏ = 0 gán con trỏ thành 0, và bây giờ đột nhiên bạn đã mất — bạn đã tràn, bạn đã rò rỉ bộ nhớ mà malloc đã cấp cho bạn.
Malloc gave you some memory, then you just erased it. So now you have no way to get back and free it again.
Malloc cấp cho bạn một vùng bộ nhớ, rồi bạn vừa xoá nó đi. Vậy nên bây giờ bạn không có cách nào để quay lại và giải phóng nó.
That was bad, because you overrode it by saying pointer = 0, and it's always going to be false. Even though malloc was successful. That's a buggy thing. So pointer == 0.
Đó là điều tồi tệ, vì bạn đã ghi đè lên nó bằng cách viết pointer = 0, và nó luôn luôn sai. Mặc dù malloc đã thành công. Đó là một lỗi lập trình. Vì vậy pointer == 0.
So it turns out what people do is they'll write 0 == pointer. If you ever mistake it with one equal sign, 0 = pointer doesn't make any sense, and that'll be an error there.
Vì vậy nó ra là mọi người sẽ viết 0 == pointer. Nếu bạn vô tình dùng một dấu bằng, 0 = pointer thì không có ý nghĩa gì, và điều đó sẽ gây lỗi ở đó.
But 0 == pointer actually works. So they'll flip it around, really interesting. So you test if 0 == pointer as a way to make sure that it's there.
Nhưng 0 == pointer thực sự hoạt động. Vì vậy họ sẽ đảo ngược nó, thực sự thú vị. Vì vậy bạn kiểm tra nếu 0 == pointer như một cách để đảm bảo rằng nó được cấp phát.
And so 0 == pointer, and if that's the case, then you say error, I couldn't get memory.
Và nếu 0 == pointer, thì bạn nói là lỗi, tôi không lấy được bộ nhớ.
You gracefully handle it, and you do something else say, hey, sorry, you asked for some memory, I couldn't give it to you.
Bạn xử lý nó một cách nhẹ nhàng, và bạn làm cái gì khác, nói là, sorry, bạn yêu cầu một số bộ nhớ, tôi không thể cấp cho bạn.
Otherwise, you keep going and you got the memory, you can now use it. So the line over here on the right says, IP integer pointer equals this malloc guy.
Nếu không thì bạn tiếp tục và bạn đã lấy được bộ nhớ, bạn có thể sử dụng nó ngay bây giờ. Vậy dòng ở đây bên phải nói, IP integer pointer bằng cái malloc này.
I asked for 10 integers, and you always check for it == 0, after that call. Then I'm going to reallocate it. Say, you know what? I said 10?
Tôi yêu cầu 10 số nguyên, và bạn luôn kiểm tra it == 0, sau cuộc gọi đó. Rồi tôi sẽ cấp phát lại nó. Nói là, bạn biết không? Tôi nói 10?
I really meant 20. I meant 20, and so you realloc, all of a sudden it's 10, now it's 20. Okay?
Tôi thực sự có ý là 20. Tôi có ý là 20, rồi bạn realloc, bỗng nhiên nó là 10, bây giờ nó là 20. Được không?
Now the key is, it is supposed to- if it's bigger- it is supposed to move the material over.
Bây giờ điều quan trọng là, nó được cho là- nếu nó lớn hơn- nó được cho là sẽ di chuyển dữ liệu sang.
It might actually give you, say, I don't have 10 here, but I have 20 over here. I have 20 here. But I have 20 over here.
Nó có thể thực sự cho bạn, chẳng hạn, tôi không có 10 ở đây, nhưng tôi có 20 ở chỗ khác. Tôi có 20 ở đây. Nhưng tôi có 20 ở chỗ khác.
So actually I'll go here, and what it's supposed to do, if it all works, it's supposed to move the 10 over, whatever content you had in there, you filled it with 10 values, 1 through 10.
Vì vậy thực sự tôi sẽ đi đến đây, và những gì nó được cho là sẽ làm, nếu tất cả hoạt động, nó được cho là sẽ di chuyển 10 cái sang, bất kỳ nội dung nào bạn có ở đó, bạn đã điền nó với 10 giá trị, từ 1 đến 10.
I moved over here, and now I've got 20 I can access. It's supposed to have moved the original 10 over, so it's actually pretty cool to do it automatically.
Tôi di chuyển sang đây, và bây giờ tôi có 20 cái tôi có thể truy cập. Nó được cho là sẽ chuyển 10 phần tử ban đầu sang, nên thực tế nó khá hay khi tự động hóa việc này.
So realloc is really nice. But check it. It might not have worked.
Vậy realloc thực sự rất tiện lợi. Nhưng hãy kiểm tra. Có thể nó không hoạt động.
So make sure you check it, and make sure that the content is — first of all, check if it's null, and also check if it did the resize correctly.
Vì vậy hãy chắc chắn kiểm tra, và chắc chắn rằng nội dung là — trước hết, kiểm tra xem có null không, và cũng kiểm tra xem nó có thay đổi kích cỡ đúng không.
If it doesn't work, it's 0. It'll return null, and it's there. If you want to free it, I don't recommend this.
Nếu nó không hoạt động, nó là 0. Nó sẽ trả về null, và nó ở đó. Nếu bạn muốn giải phóng nó, tôi không khuyên bạn làm vậy.
I would prefer you call free, you can say realloc (ip,0), it's the same as a free. It says, you know what? I don't want anything anymore. That's the same way as calling free.
Tôi thích hơn bạn gọi free, bạn có thể nói realloc (ip,0), nó giống như một free. Nó nói, biết đấy, tôi không muốn gì nữa. Điều đó cũng giống như gọi free.
But I prefer to call free myself explicitly. Now, arrays are strange. Arrays are not implemented as you'd think. Let me get my pen here, and make sure I've got this going.
Nhưng tôi thích gọi free một cách rõ ràng. Bây giờ, các mảng là những thứ kỳ lạ. Các mảng không được triển khai như bạn tưởng. Hãy để tôi lấy bút của tôi ở đây, và chắc chắn rằng tôi đã bật nó.
So here's a piece of code, foo, and here's an array. First line, okay, here we go. Int* p, *q, x. X is an integer, what's its contents?
Vậy đây là một đoạn mã, foo, và đây là một mảng. Dòng đầu tiên, được rồi, bắt đầu nào. Int* p, *q, x. X là một số nguyên, nội dung của nó là gì?
Garbage. P and Q are pointers. What's their contents? Garbage.
Rác. P và Q là các con trỏ. Nội dung của chúng là gì? Rác.
When pointers have garbage contents, we draw their pointers as kind of pointing who knows where. It's like, who knows where? I don't know. Here is int. a(4).
Khi các con trỏ có nội dung rác, chúng ta vẽ các con trỏ của chúng như là chỉ đến một nơi không ai biết. Nó như, ai biết được nó chỉ tới đâu? Tôi không biết. Đây là int. a(4).
Now, where does a live? I don't know. See, arrays are not implemented like you think they would be. OK?
Vậy, a nằm ở đâu? Tôi không biết. Thấy không, mảng không được triển khai như bạn tưởng. Được chứ?
But, a(4) says, here's four integers. I'm going to give you, and they're all contiguous, we know they're always contiguous. Malloc returns the contiguous memory, and so does a(4).
Nhưng, a(4) nói, đây là bốn số nguyên. Tôi sẽ cho bạn, và chúng liên tiếp nhau, chúng ta biết chúng luôn liên tiếp nhau. Malloc trả về bộ nhớ liên tiếp, và a(4) cũng vậy.
Okay, so now here we go. Let me clear this here. Next line, next line. P = — there's like the three ways to do this now.
Được rồi, bây giờ chúng ta đi. Để tôi xóa cái này đi. Dòng tiếp theo, dòng tiếp theo. P = — hiện có ba cách để làm điều này.
Well, I mean there's the raw way, to say x. Here's a(4), that's an array way, and now there's the malloc way. That's why I'm showing you this one.
Vâng, ý tôi là có cách thô sơ, để nói x. Đây là a(4), đó là cách dùng mảng, và bây giờ có cách malloc. Đó là lý do tôi chỉ cho bạn cách này.
This is p= int* malloc, sizeof int. Just makes one int. Again, usually don't call it, you just say n times size int, or some size like that. So I make a new integer.
Đó là p = int* malloc, sizeof int. Chỉ tạo một int. Như thường lệ, thường không gọi nó như vậy, bạn chỉ nói n lần size int, hoặc một kích thước nào đó như vậy. Vì vậy tôi tạo một integer mới.
So what happens? Over here is the result of malloc. That's the result of malloc. I made some new space.
Vậy điều gì sẽ xảy ra? Ở đây là kết quả của malloc. Đó là kết quả của malloc. Tôi tạo ra một không gian mới.
I made an integer. And p is going to point to it. When something points to something, its address, here 40, is the value of the pointer. So 40, 40, makes sense.
Tôi tạo ra một integer. Và p sẽ trỏ đến nó. Khi một cái gì đó trỏ tới một cái gì đó, địa chỉ của nó, ở đây là 40, chính là giá trị của con trỏ. Vậy 40, 40, là hợp lý.
Okay, so p points to that malloc integer over there. Now q equals address of x, So now q is going to x, x doesn't have a value yet.
Được, vậy p trỏ tới cái malloc integer kia. Bây giờ q bằng địa chỉ của x, vậy bây giờ q sẽ trỏ tới x, x chưa có giá trị.
But it points to it, okay? So I've got these three uninitialized integers. 1, 2 and 3. Let's see what actually is going to happen.
Nhưng nó trỏ tới nó, được không? Vậy tôi có ba cái integer chưa được khởi tạo. 1, 2 và 3. Hãy xem điều gì sẽ thực sự xảy ra.
Here we go.
Nào.
*P = 1. Okay? I follow the pointer. I follow the pointer, and I stuff a 1 there.
*P = 1. Được không? Tôi theo con trỏ. Tôi theo con trỏ, và tôi đặt một 1 vào đó.
As a result of that line, *p equals 1. Okay?
Kết quả của dòng đó là *p bằng 1. Okay?
And so now, if I ask for p — *p, p, and address of p, what should it give me? *P, follow it.
Và bây giờ, nếu tôi yêu cầu p — *p, p, và địa chỉ của p, nó sẽ cho tôi cái gì? *P, làm theo nó.
Okay? P, there's p. What's the address of p? Okay?
Okay? P, đó là p. Địa chỉ của p là gì? Okay?
So let's see what it prints out. Ready? Oop. *P1.
Vậy hãy xem nó in ra cái gì. Ready? Oop. *P là 1.
P is 40. Address would be 12. Makes sense, right? Thumbs up.
P là 40. Địa chỉ sẽ là 12. Có ý nghĩa đúng không? Thumbs up.
Now, next line. *Q=2. Remember this guy was uninitialized still. *Q = 2. There we go.
Được rồi, dòng tiếp theo. *Q=2. Nhớ lại rằng cái này vẫn chưa được khởi tạo. *Q = 2. Được rồi.
And now let's ask for *q, q, and address of q. Okay, here we go. Ready?
Và bây giờ chúng ta hỏi *q, q, và địa chỉ của q. Được rồi, chúng ta đi. Sẵn sàng chưa?
*Q, q, 1, 20, address of q, 16. 2, 20, and 16. Any questions? Pretty good, right?
*Q, q, 1, 20, địa chỉ của q, 16. 2, 20, và 16. Có ai có câu hỏi không? Khá tốt đúng không?
I'll wait. Feel free to ask your question. I'm so used to doing this dynamic. This video thing is very strange, by the way.
Tôi sẽ chờ. Cứ tự do hỏi câu hỏi của bạn. Tôi đã quen với việc làm cái này một cách động. Cái việc quay video này rất lạ, nhân tiện.
I just need to say, doing this in front of a camera is very strange. Finally, *a is 3. Let's see what happens. Ready?
Tôi chỉ cần nói, làm cái này trước mặt camera rất lạ. Cuối cùng, *a bằng 3. Chúng ta xem chuyện gì xảy ra. Sẵn sàng chưa?
Bloop. Okay, so what a was pointing to is now three. Here we go. *A, a, address of a.
Bloop. Okay, vậy *a đang trỏ đến bây giờ là ba. Nào. *a, a, địa chỉ của a.
Let's do it. Ready? Here we go, *a, we know it's three. A, well, we got to have 24, because obviously that's what it was.
Làm nào. Sẵn sàng chưa? Nào, *a, chúng ta biết nó bằng ba. a, chúng ta phải có 24, vì rõ ràng đó là đó là cái chúng ta có.
That's what is there. Where does a live? What's the address of a? Let's just see this.
Đó là cái ở đó. a sống ở đâu? Địa chỉ của a là gì? Hãy để xem cái này.
It's a little strange. Ready? Hear that glass breaking sound? How is the address of a 24?
Nó hơi kỳ lạ. Sẵn sàng chưa? Nghe thấy tiếng kính vỡ không? Làm sao địa chỉ của a lại là 24?
How does that make any sense?
Cái gì có thể giải thích được điều này?
Address of a isn't 24. This isn't a. That's not — it doesn't make any — so a is 24, right? A, the value a, that points to 24.
Địa chỉ của a không phải là 24. Cái này không phải a. Đó là — nó không có ý nghĩa gì — vậy a là 24, phải không? A, giá trị a, nó trỏ tới 24.
So this guy has 24 inside of it. But the address, where does a live? That's not 24.
Vậy nên cái này chứa 24 bên trong nó. Nhưng địa chỉ, biến a nằm ở đâu? Đó không phải là 24.
The reason is that arrays are not implemented as you think, or as K&R says, an array name is not a variable.
Lý do là các mảng không được cài đặt như bạn nghĩ, hoặc như K&R nói, tên mảng không phải là một biến.
You're going to see when we get to the assembly level why that is. Remember, this weird, uncomfortable feeling right now, because when we get to assembly, you're going to see.
Bạn sẽ thấy khi chúng ta tiến tới mức độ assembly tại sao lại như vậy. Hãy nhớ, cảm giác kỳ lạ, không thoải mái này ngay bây giờ, bởi vì khi chúng ta tiến tới assembly, bạn sẽ thấy.
Oh, now I know. Remember that slide Dan showed me? Now I know why that is. So, mini summary for this little mini lecture here.
Aha, giờ tôi hiểu rồi. Bạn còn nhớ slide Dan chỉ cho tôi không? Giờ tôi biết tại sao lại như vậy. Vậy, một tóm tắt nhỏ cho bài giảng nhỏ này.
Pointers and arrays are virtually the same, except for that little exception I showed you about there about where they live, and that you can't increment an array, open square bracket variable.
Con trỏ và mảng về cơ bản là giống nhau, ngoại trừ cái ngoại lệ nhỏ mà tôi chỉ cho bạn kia về nơi chúng tồn tại, và bạn không thể tăng mảng, dấu ngoặc vuông mở biến.
C knows how to increment pointers, plus and minus, it knows what the sizeof is, and moves them around. It's an efficient language with little protection. It's basically going to let you hurt yourself.
C biết cách tăng con trỏ, cộng và trừ, nó biết sizeof là bao nhiêu, và di chuyển chúng xung quanh. Đó là một ngôn ngữ hiệu quả với ít sự bảo vệ. Về cơ bản nó sẽ cho phép bạn tự hại mình.
It's a very sharp edged car, a very sharp edged car, a car with no plastic around it. You're just a wild engine running there. Use handles to change pointers, I said that.
Đó là một chiếc xe rất sắc nhọn, rất sắc nhọn, một chiếc xe không có nhựa bao quanh nó. Bạn chỉ là một động cơ hoang dã chạy ở đó. Sử dụng các tay cầm để thay đổi con trỏ, tôi đã nói như vậy.
We saw the Godfather, where you can use malloc and free, but you got to promise to return and free the stuff you borrow from the memory you borrow using malloc.
Chúng ta đã xem Godfather, nơi bạn có thể sử dụng malloc và free, nhưng bạn phải hứa sẽ trả về và giải phóng những thứ bạn mượn từ bộ nhớ bạn mượn bằng malloc.
And you get something, you know ain't no free lunch, folks. Ain't no free lunch. What do you get for that speed? What you get for that speed is a lot of rope.
Và bạn có được thứ gì đó, bạn biết không có bữa trưa miễn phí nào cả, các bạn. Không có bữa trưa miễn phí. Bạn nhận được cái gì đổi lấy tốc độ đó? Cái bạn nhận được đổi lấy tốc độ là rất nhiều tự do.
That speed is remarkable. But you get a lot of rope that you can hang yourself with. So don't. Know about all these gotchas, and try to avoid them.
Tốc độ đó thực sự đáng chú ý. Nhưng bạn nhận được rất nhiều tự do mà bạn có thể tự treo cổ mình. Vậy đừng làm vậy. Hãy biết về tất cả những cạm bẫy này và cố gắng tránh chúng.
See you at the next lecture.
Hẹn gặp 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.