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. 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 sự trở lại. Bây giờ chúng ta hãy thực sự thực tế và giải thích cho bạn cách thực sự làm việc với bộ nhớ thực. Vậy đây chính là điểm khác biệt giữa 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ẽ kiểm soát được lượng bộ nhớ bạn nhận được, và bạn muốn bao nhiêu, và làm thế nào để giải phóng nó và làm tất cả những thứ đó. Chúng ta hãy nói về vấn đề này ngay hôm nay.
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 ta đã biết rằng C có hàm sizeof này, cung cấp kích thước và số byte của thứ bạn truyền vào, điều đó thật tuyệt vời và đó có thể là một loại hoặc nó có thể là một biến, điều này rất tốt.
And back in the day, ints were 16 bits. So you could ask, size of int 30 years ago, 40 years ago, 30 maybe.
Ngày xưa, int có 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 năm.
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 là 2, và bây giờ nó sẽ nói là 4, và có lẽ bây giờ nó sẽ sớm nói là 8. Đây một lần nữa là lý do tại sao tô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 được loại mảng. Nếu tôi có int. ar là 3, kích thước của ar, nó sẽ hiển thị là 12. Đó là ba số nguyên, do đó 3 lầ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 khi chạy. Vậy đây là Ar(n), là một số động, hoặc đó là 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 số hàm có giá trị, có giá trị bằng 3 và ar của nó bằng 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 lần nữa, nó vẫn sẽ báo là 12 cho kích thước của số số byte bạn có. Vì vậy, đây là lần đầu tiên chúng ta từng được nói đến 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ớ một cách năng động, ngoài mảng, còn 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ẽ sớm xuất hiện. Vậy đây là lần đầu tiên bạn 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 nên tôi nói, con trỏ, tôi có một con trỏ đến một mảng số nguyên. Tôi sẽ nói là mảng số nguyên. Tôi tuyên bố nó là 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ì vậy malloc là một hàm thực hiện theo số byte bạn muốn và trả về một con trỏ đến không gian chưa khởi tạo. Vì thế nó không được khởi tạo. Hãy nhớ rằng 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ề dưới dạng void*, vì nhìn chung nó không biết nó muốn gì. Nó sẽ trả về giá trị void*.
Remember, void* a pointer to a generic space, to the generic array, you have to cast that.
Hãy nhớ, void* là con trỏ tới một không gian chung, đối với mảng chung, bạn phải ép kiểu dữ liệu đó.
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 rằng, nếu con trỏ được khai báo là int*, vì vậy con trỏ int*, sau đó bạn phải ép kiểu bằng this. Và điều đó sẽ cho hệ thống biết là đừ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ề void*, nhưng tôi muốn ép kiểu nó dưới dạng int*, do đó dấu bằng sẽ 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ậy thì tốt. Được rồi? Chỉ có thế thôi. Nó được gọi là kiểu đúc.
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 đã từng chứng kiến điều đó. Thực ra, đó là lần đầu tiên chúng tôi thấy điều đó. Tuy nhiên, Malloc hầu như không bao giờ được giữ lại. Tại sao bạn lại sử dụng malloc chỉ để lấy một số nguyên?
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 int, hãy tạo fu. Int.fu, có một số nguyên. Có lẽ bạn sẽ muốn có một mảng nếu bạn muốn có nhiều mảng. Đây là cách thông thường mà người ta thường thực hiện.
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ó kích thước gấp n lần. Vì vậy, tôi muốn một mảng gồm n số nguyên, và con trỏ trỏ tới 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 có dấu ngoặc vuông. Nhưng dù sao thì nó vẫn là một mảng, chúng ta vẫn gọi chúng là mảng. Vì vậy, một khi malloc được gọi, vị trí bộ nhớ chứa Rác thải, bạn biết điều này 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 mọi thứ. Chúng tôi không bao giờ thiết lập lại mọi thứ. C quá nhanh. Vì vậy, đó sẽ là một tập hợp chưa được khởi tạo của — nếu nó là ba anh chàng, 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ỉ có 12 byte không có gì cả. Ai biết chúng là gì? Điều quan trọng là khi bạn hoàn thành không gian đó, bất kể con trỏ, bất kể malloc trả về giá trị gì thì đó 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à con trỏ tới điểm bắt đầ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 giống như là — Tôi không biết, nó gần giống như việc đi xem Bố già vậy và yêu cầu giúp đỡ.
Godfather, I would like some memory from you.
Bố già ơi, con muốn xin bố một chút ký ức.
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 đó có thể không bao giờ đến, Tôi có thể nhờ bạn giúp tôi một việc.
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 đó, tôi sẽ cho bạn một ít malloc, theo hợp đồng và bạn phải trả lại khi hoàn tất. Đấy là tôi bắt chước Bố già đấy.
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 đang diễn ra để giải phóng nó khi bạn hoàn thành, đừng làm điều đó. Đừng để chương trình giải phóng nó cho bạn. Hãy chắc chắn rằng bạn tự mình 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? Bởi vì bạn không bao giờ biết khi nào chương trình chính của bạn trở thành chương trình con. Họ nói, ồ, đây thực sự là điều thú vị. Để tôi gói nó trong một chương trình con ở đâ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.
Nhân tiện, nhưng bạn chưa bao giờ giải phóng nó. Vậy nên bây giờ, main này không bao giờ giải phóng được nó. Chúng tôi gọi đây là rò rỉ bộ nhớ và đột nhiên đó là một chương trình con.
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ả ký ức mà bạn mong muốn, nó cứ thế tuôn trào. Nó không bị đổ, mà 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à sự rò rỉ bộ nhớ và điều đó thực sự tệ. Vì vậy, bạn không muốn điều đó. Vậy thì chắc chắn hãy nghe Bố già, 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 tất, và có có rất nhiều chi tiết, bạn không thể sử dụng nó sau khi hết thời gian miễn phí. Khi bạn được tự do, mọi việc đã xong.
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ứ điều gì malloc cung cấp cho bạn, con trỏ đó, bạn tốt hơn truyền con trỏ đó đến free, một ngày nào đó, sử dụng nó, sử dụng nó, sử dụng nó, sau đó chuyển nó cho miễn phí, 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.
Một lần nữa, điều quan trọng. Vậy thì, đây là một số điều có thể khiến bạn lo lắng. Chúng ta sẽ thấy điều này rất nhiều. Bởi vì tôi muốn chắc chắn rằng bạn nhìn thấy tất cả những điều này điều đó sẽ cắn 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.
Bởi vì chúng sẽ cắn bạn. Họ cắn tôi, về cơ bản là họ cắn 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, một khi bạn giải phóng nó một lần, bạn không thể chạm vào nó nữa. Nó ở ngoài kia. Và có thể tái sử dụng được, nên bạn không thể giải phóng 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 là miễn phí cho thứ mà bạn không nhận lại được từ malloc. Vậy là tôi có được, đây là một malloc. Bạn chỉ có thể gọi miễn phí cho anh chàng đó thôi, bạn không thể giải phóng 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 miễn phí trên con trỏ mới. Bạn phải gọi miễn phí đến địa chỉ chính xác được trả lại từ malloc. Được rồi?
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ậy thì có ba điều bạn có thể làm sai. Nếu tôi nói với bạn malloc, và sau đó giải thoát cho anh chàng đó cuối cùng sau khi bạn hoàn thành xong. Được rồi, bạn đã hoàn thành xong việc đó.
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 sau đó bạn giải phóng nó hai lần, tệ, hoặc bạn gọi là miễn phí, và sau đó — trên một thứ không phải như vậy. Hoặc bạn không giải phóng nó chút nào. Có rất nhiều cách để bạn có thể làm hỏng mọi chuyện.
And the runtime doesn't check for it. It doesn't check for this. C is too fast, C is too performance critical.
Và thời gian chạy không kiểm tra điều đó. Nó không kiểm tra điều 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 điều này, mã của bạn sẽ hoặc là bị bỏ lại trong một sự không nhất quán trạng thái, vì bạn đã làm hỏng bộ phân bổ 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 này thật tệ.
You're running a server. All of a sudden, why does the server crash?
Bạn đang chạy một máy chủ. Đột nhiên, tại sao máy chủ lại bị sập?
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, bởi vì bạn đã làm một số điều kỳ lạ với malloc và free lúc đó, và sau đó cuối cùng bạn phải trả giá sau này, tệ thật. Giống như việc không đánh răng vậy.
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 đi, vì nhiều năm sau, bạn sẽ phải trả giá. Hãy tin tôi. Tôi ổn, vấn đề ở đây là vậy. Thì ra là, đượ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?
Không gian rộng lớn. Được rồi. Nhưng thú vị, nếu tôi muốn thì sao làm cho nó to hơn hay nhỏ hơn? Tôi có thể thay đổi kích thước của 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.
Chắc chắn! Vì vậy nó được gọi là realloc. Realloc lấy con trỏ, con trỏ gốc malloc đã đưa cho bạn. Vì vậy, tôi đã trả về một anh chàng từ malloc như một con trỏ tới đó.
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 muốn nhiều hơn nữa. Tôi muốn gấp đôi, gấp 5 lần hoặc tôi muốn nhỏ hơn. Tôi có thể gọi realloc và nó sẽ 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.
Bây giờ, điều tôi chưa nói với bạn, điều này là thứ ở trang chiếu trước, malloc đôi khi không thể đáp ứng yêu cầu của bạn. Tôi muốn 4 nghìn 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 có một khoảng không gian nhất định, và có thể không gian đó đã hết. Có thể toàn bộ không gian bạn có thể truy cập đã đầy. Malloc phải có chế độ 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 cùng suy nghĩ xem, chế độ hỏng hóc của nó là gì? Trước đây, tôi đã nói với bạn về cấp độ Unix , khi bạn trả về 0, đó là thành công, mọi thứ khác đều là thất bại. Nhưng ở đây, người canh gác cho trí 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 của malloc là gì? có thể trở lại mà chúng ta biết không bao giờ có thể có phải là giá trị hợp lệ mà malloc có thể trả về không? 0, rỗng.
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 đến malloc tốt hơn nên có dòng tiếp theo, bạn kiểm tra xem con trỏ có ==0 không.
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 sai lầm ban đầu của mọi người make là kiểm tra xem con trỏ có = 0 không, tốt, con trỏ = 0 gán con trỏ cho 0, và bây giờ đột nhiên bạn đã mất — bạn đã đổ, bạn đã rò rỉ ký ức malloc đã đưa 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 đã cung cấp cho bạn một ít ký ức, sau đó bạn lại xóa nó đi. Vậy nên bây giờ bạn không còn cách nào để quay lại và giải phóng nó nữa.
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.
Điều đó thật tệ, vì bạn đã ghi đè nó bằng cách nói con trỏ = 0, và nó sẽ luôn luôn sai. Mặc dù malloc đã thành công. Cái đó có lỗi lắm. Vì vậy con trỏ == 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ậy thì hóa ra mọi người sẽ viết 0 == con trỏ. Nếu bạn từng nhầm lẫn nó với một dấu bằng, 0 = con trỏ không có ý nghĩa gì, và đó sẽ là một 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 con trỏ 0 == thực sự hoạt động. Vì vậy, họ sẽ lật ngược lại, điều này thực sự thú vị. Vì vậy, bạn kiểm tra xem 0 == con trỏ như một cách để đảm bảo rằng Nó ở đó.
And so 0 == pointer, and if that's the case, then you say error, I couldn't get memory.
Và do đó 0 == con trỏ, và nếu đúng như vậy, sau đó bạn báo 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 duyên dáng, và bạn làm điều gì khác nói, này, xin lỗi, Bạn đã yêu cầu một chút ký ức, tôi không thể cho bạn được.
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, bạn cứ tiếp tục và bạn sẽ có được ký ức, Bây giờ bạn có thể sử dụng nó. Vì vậy, dòng ở đây bên phải nói rằng, con trỏ nguyên IP bằng với thằng 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 nó == 0, sau cuộc gọi đó. Sau đó tôi sẽ phân bổ lại nó. Nói đi, bạn biết gì không? Tôi nói là 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ự là 20. Ý tôi là 20, và vì vậy bạn phân bổ lại, đột nhiên nó là 10, bây giờ là 20. Được rồi?
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à như vậy - nếu nó là lớn hơn- nó được cho là có thể di chuyển vật liệu qua.
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ó thực sự có thể cung cấp cho bạn, ví dụ, tôi không có 10 ở đây, nhưng tôi có 20 cái ở đây. Tôi có 20 ở đây. Nhưng tôi có 20 cái ở đây.
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 ra tôi sẽ đi đến đây, và những gì nó được cho là làm, nếu mọi thứ đều ổn, nó sẽ di chuyển 10 qua, bất kỳ nội dung nào bạn có trong đó, bạn đã điền vào đó 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 đã chuyển đến đây và hiện tại tôi có thể truy cập được 20 trang web. Nó được cho là đã di chuyển 10 bản gốc qua, vì vậy, thực ra khá thú vị khi thực hiện điều đó một cách tự động.
So realloc is really nice. But check it. It might not have worked.
Vậy thì realloc thực sự rất tuyệt. Nhưng hãy kiểm tra lại nhé. Có thể nó không hiệu quả.
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 đảm bảo rằng bạn kiểm tra nó và chắc chắn rằng nội dung là — trước hết, hãy kiểm tra xem nó có null không, và kiểm tra xem nó có thay đổi kích thướ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 không hoạt động thì là 0. Nó sẽ trả về giá trị null và nó ở đó. Nếu bạn muốn giải phóng nó, tôi không khuyên bạn làm như 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 muốn bạn gọi là miễn phí, bạn có thể nói realloc (ip,0), nó giống như miễn phí vậy. Nó nói rằng, bạn biết gì không? Tôi không muốn gì nữa. Tương tự như gọi miễn phí.
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 bản thân tôi thích gọi nó là miễn phí một cách rõ ràng hơn. Bây giờ, mảng rất lạ. Mảng không được triển khai như bạn nghĩ. Để tôi lấy bút đây và chắc chắn là tôi đã làm xong việc này.
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?
Đây là một đoạn mã, foo, và đây là một mảng. Dòng đầu tiên, được rồi, chúng ta bắt đầu thôi. Số nguyên* 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 con trỏ có nội dung rác, chúng ta vẽ các con trỏ của chúng như thể chúng đang chỉ vào một nơi nào đó. Giống như là, ai biết ở đâ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, con người sống ở đâu? Tôi không biết. Bạn thấy đấy, mảng không được triển khai như bạn nghĩ. ĐƯỢC RỒI?
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 rằng, đây là bốn số nguyên. Tôi sẽ cho bạn, và tất cả chúng đều liền kề nhau, chúng ta biết chúng luôn tiếp giáp nhau. Malloc trả về bộ nhớ liền kề 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 bắt đầu nhé. Để tôi làm rõ vấn đề này nhé. Dòng tiếp theo, dòng tiếp theo. P = — hiện tại có khoảng ba cách để thực hiện việc 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ó một cách thô sơ hơn, đó là nói x. Đây là a(4), đó là một cách mảng, và bây giờ có cách malloc. Đó là lý do tại sao tôi cho bạn xem cái 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.
Đây là p= int* malloc, sizeof int. Chỉ tạo một int. Một lần nữa, thường thì đừng gọi nó, bạn chỉ cần nói n lần kích thước int hoặc một kích thước nào đó tương tự. Vì vậy, tôi tạo một số nguyên 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 chuyện gì 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 số 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 một số nguyên. Và p sẽ trỏ tới nó. Khi một cái gì đó chỉ vào một cái gì đó, địa chỉ của nó, ở đây là 40, là giá trị của con trỏ. Vậy thì 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 rồi, vậy p trỏ tới số nguyên malloc ở đó. Bây giờ q bằng địa chỉ của x, vậy bây giờ q sẽ tiến 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ó chỉ ra điều đó, được chứ? Vậy là tôi có ba số nguyên chưa được khởi tạo này. 1, 2 và 3. Chúng ta hãy cùng xem điều gì thực sự sẽ xảy ra.
Here we go.
Chúng ta bắt đầu thôi.
*P = 1. Okay? I follow the pointer. I follow the pointer, and I stuff a 1 there.
*P = 1. Được rồi? Tôi đi theo con trỏ. Tôi theo con trỏ và điền số 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. Được rồi?
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, theo nó.
Okay? P, there's p. What's the address of p? Okay?
Được rồi? P, có p. Địa chỉ của p là gì? Được rồi?
So let's see what it prints out. Ready? Oop. *P1.
Vậy chúng ta hãy xem nó in ra những gì nhé. Sẵn sàng? Mở. *P1.
P is 40. Address would be 12. Makes sense, right? Thumbs up.
P là 40. Địa chỉ sẽ là 12. Có lý phải không? Thích quá.
Now, next line. *Q=2. Remember this guy was uninitialized still. *Q = 2. There we go.
Bây giờ, dòng tiếp theo. *Q=2. Hãy nhớ rằng anh chàng này vẫn chưa được khởi tạo. *Q = 2. Đấy, thế là xong.
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ãy hỏi *q, q và địa chỉ của q. Được rồi, bắt đầu thôi. Sẵn sàng?
*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. Bạn có thắc mắc gì không? Khá tốt phải 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ẽ đợi. Hãy thoải mái đặt câu hỏi. Tôi đã quá quen với việc làm động tác này. Nhân tiện, cái video này rất kỳ lạ.
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 rằng, làm điều này trước máy quay thật là kỳ lạ. Cuối cùng, *a là 3. Chúng ta hãy xem điều gì sẽ xảy ra. Sẵn sàng?
Bloop. Okay, so what a was pointing to is now three. Here we go. *A, a, address of a.
Bụp. Được rồi, vậy thì số a đang trỏ tới bây giờ là số ba. Chúng ta bắt đầu thôi. *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.
Hãy cùng làm nhé. Sẵn sàng? Đây rồi, *a, chúng ta biết là ba. A, tốt, chúng ta phải có 24, bởi vì rõ ràng là đó là gì.
That's what is there. Where does a live? What's the address of a? Let's just see this.
Đấy là những gì có ở đó. A sống ở đâu? Địa chỉ của a là gì? Chúng ta hãy cùng xem nhé.
It's a little strange. Ready? Hear that glass breaking sound? How is the address of a 24?
Có vẻ hơi lạ. Sẵn sàng? Bạn có nghe thấy tiếng kính vỡ không? Địa chỉ của số 24 như thế nào?
How does that make any sense?
Điều đó có ý nghĩa gì?
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. Đây không phải là một. Không phải vậy — nó không tạo ra bất kỳ — nào — vì vậy a là 24, đúng không? A, giá trị a, 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 thì anh chàng này có 24 người bên trong. Nhưng địa chỉ nhà anh ấy ở đâ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à mảng không được triển khai 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 đạt đến cấp độ lắp ráp tại sao lại như vậy. Hãy nhớ rằng, điều kỳ lạ, khó chịu này cảm giác ngay bây giờ, bởi vì khi chúng ta đến buổi họp, 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.
Ồ, giờ thì tôi biết rồi. Bạn còn nhớ slide Dan cho tôi xem không? Bây giờ tôi biết tại sao lại thế rồi. Vậy thì, tóm tắt ngắn gọn cho bài giảng ngắn này ở đâ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ừ ngoại lệ nhỏ mà tôi đã chỉ cho bạn về điều đó về nơi họ sống và bạn không thể tăng một mảng, biến ngoặc vuông mở.
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 kích thước của chúng là bao nhiêu và di chuyển chúng xung quanh. Đây là một ngôn ngữ hiệu quả nhưng ít được bảo vệ. Về cơ bản, nó sẽ khiến bạn tự làm tổn thương 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 cạnh, một chiếc xe rất sắc nét xe có viền, xe không có lớp nhựa xung quanh. Bạn chỉ là một động cơ hoang dã đang chạy ở đó. Tôi đã nói là sử dụng tay cầm để thay đổi con trỏ.
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 tôi đã xem Bố già, nơi bạn có thể sử dụng malloc và miễn phí, nhưng bạn phải hứa sẽ quay lại và giải thoát những thứ bạn mượn từ bộ nhớ bạn mượn bằng cách sử dụ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 nhận được thứ gì đó, các bạn biết đấy, không có bữa trưa nào là miễn phí cả. Không có bữa trưa nào là miễn phí. Bạn nhận được gì với tốc độ đó? Những gì bạn nhận được cho tốc độ đó là rất nhiều dây thừng.
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ật đáng kinh ngạc. Nhưng bạn sẽ có rất nhiều dây thừng để có thể tự treo cổ mình. Vì vậy đừng làm thế. Hãy tìm hiểu về những điều cần lưu ý này và cố gắng tránh chúng.
See you at the next lecture.
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.