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