Video
Đăng bởi Quản trị viên OpenER ·
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 learn about what a pointer is — exciting. We titled this bugs and pointers because, really, that's what's — this is the source of so many bugs.
Chào mừng các bạn quay lại. Bây giờ, chúng ta hãy tìm hiểu con trỏ là gì — thú vị đấy. Chúng tôi đặt tên chủ đề này là lỗi và con trỏ bởi vì, thực ra, đó là nguồn gốc của rất nhiều lỗi.
It's so sad to share with you. This is like giving you a very sharp-edged thing with a blade and the cut, and don't cut yourself.
Thật buồn khi chia sẻ điều này với các bạn. Giống như chúng tôi đang cho các bạn một cái gì đó rất sắc cạnh với một lưỡi dao và vết cắt, và đừng cắt chính mình.
Well, you're going to cut yourself, and you're going to have bugs, thanks to pointers. So pointers is the reason for this whole thing. But they're powerful. We'll talk about that the last slide.
Chà, các bạn chắc chắn sẽ cắt chính mình, và các bạn sẽ có lỗi, cảm ơn những con trỏ. Vì vậy con trỏ là lý do cho toàn bộ điều này. Nhưng chúng rất mạnh mẽ. Chúng tôi sẽ nói về điều đó ở slide cuối cùng.
We'll talk about why we use pointers in the first place. So more about variable declaration — so mostly, it's similar to Java, except that Java declares variables.
Chúng tôi sẽ nói về lý do tại sao chúng tôi sử dụng con trỏ ngay từ đầu. Vì vậy thêm về khai báo biến — nên phần lớn, nó tương tự như Java, ngoại trừ Java khai báo biến.
And that gives them a default value that makes sense for that variable. If it's a number, it gives it zero, probably.
Và điều đó cấp cho chúng một giá trị mặc định mà có ý nghĩa đối với biến đó. Nếu nó là một số, nó cấp cho nó số không, có lẽ.
Not in C. C, when you make a new variable without giving it a value, garbage. I'll say it again — garbage. It has no idea. It's a box, and it's unknown inside.
Không phải trong C. C, khi bạn tạo một biến mới mà không cấp cho nó một giá trị, rác rưởi. Tôi sẽ nói lại — rác rưởi. Nó không biết gì. Nó là một hộp, và bên trong là lạ lùng.
That's the source of a ton of problems. So you have to always make a new variable and then initialize it before you can use it.
Đó là nguồn gốc của rất nhiều vấn đề. Vì vậy bạn phải luôn tạo một biến mới và sau đó khởi tạo nó trước khi bạn có thể sử dụng nó.
You could have used it in Java, and you might have gotten lazy and just started using, oh, they're zero. I make a new counter. It would probably default to zero.
Bạn có thể đã sử dụng nó trong Java, và bạn có thể đã lười biếng và chỉ bắt đầu dùng, ô, chúng bằng không. Tôi tạo một bộ đếm mới. Nó có thể sẽ mặc định là không.
Let me now — as accumulator, and that added numbers to it. No. You've got to declare something.
Bây giờ để làm bộ tích lũy, và cộng các số vào nó. Không. Bạn phải khai báo thứ gì đó.
If it's garbage in, and just keep adding some numbers into it, it's going to continue to be garbage. So you got to make sure of this. So here's some example declarations.
Nếu đầu vào là rác, và chỉ tiếp tục cộng thêm một số vào nó, thì nó sẽ tiếp tục là rác. Vì vậy bạn phải chắc chắn về điều này. Vậy đây là một số khai báo ví dụ.
You used to have to declare things at the top. So int a is B. Int a is 0, b is 10. In ANSI C, you couldn't do this.
Trước đây bạn phải khai báo những thứ ở đầu. Vậy int a là B. Int a là 0, b là 10. Trong ANSI C, bạn không thể làm điều này.
In 1986, you couldn't do this for int i is 1. That's a really standard thing to do in Java. You can't do that here. But you can do it in the C99 and beyond.
Vào năm 1986, bạn không thể viết int i là 1. Đó là một điều rất tiêu chuẩn trong Java. Bạn không thể làm điều đó ở đây. Nhưng bạn có thể làm nó trong C99 và những phiên bản sau.
You can just say for int i is 0. So I mentioned that before, but it's useful to know. So undefined behavior — undefined behavior in C means it's unpredictable.
Bạn chỉ có thể nói for int i is 0. Vậy tôi đã đề cập đến điều đó trước, nhưng nó hữu ích khi biết. Vậy là hành vi không xác định — hành vi không xác định trong C có nghĩa là nó không thể đoán trước được.
It might run 100 times on one computer, and then the 101st time, doesn't work. Or it might be great in this computer — this same code, don't touch it.
Nó có thể chạy 100 lần trên một máy tính, và sau đó lần thứ 101, nó không hoạt động. Hoặc nó có thể rất tốt trên máy tính này — cùng mã này, đừng chạm vào nó.
I compile it for this computer, and it doesn't work. Or I upgrade the OS, and the program doesn't work anymore because of a new library change. All these things are undefined behavior.
Tôi biên dịch nó cho máy tính này, và nó không hoạt động. Hoặc tôi nâng cấp hệ điều hành, và chương trình không còn hoạt động do thay đổi thư viện mới. Tất cả những điều này đều là hành vi không xác định.
And a lot of these things are really challenging to find. Things that are undefined, things are kind of random, hard to reproduce, seems like — evades you, we call them Heisenbugs.
Và rất nhiều điều này thực sự khó để tìm thấy. Những điều không xác định, những điều hơi ngẫu nhiên, khó để tái tạo, có vẻ như — nó trốn tránh bạn, chúng ta gọi chúng là Heisenbugs.
If you haven't heard that, you start using that word — Heisenbugs, Heisenberg's uncertainty principle — so the quantum physics. So think about the idea that you want to avoid that.
Nếu bạn chưa nghe qua, hãy bắt đầu dùng từ này — Heisenbugs, nguyên lý bất định của Heisenberg — vật lý lượng tử vậy. Vậy hãy nghĩ đến ý tưởng rằng bạn muốn tránh điều đó.
You want to avoid that space and have — actually, you want to have repeatable bugs. Bugs that are repeatable, we can find them, right?
Bạn muốn tránh không gian đó và có — thực sự, bạn muốn có những lỗi có thể lặp lại được. Những lỗi có thể lặp lại, chúng ta có thể tìm thấy chúng, phải không?
I just logically trace it down, and I can find them. Those are called Bohrbugs.
Tôi chỉ cần suy luận logic nó ra, và tôi có thể tìm thấy chúng. Những cái đó được gọi là Bohrbugs.
So Heisenbugs, bad, hard to trace, and hard to find, and may never even show up until the millionth time you run it after you ship the code out.
Vậy Heisenbugs, xấu, khó để suy luận, và khó để tìm, và có thể thậm chí chưa bao giờ hiện ra cho đến lần thứ một triệu bạn chạy nó sau khi đã ship code ra.
That's really hard. It's really tough for you as a software developer. More bugs, easy. You can trace it.
Điều đó thực sự khó. Nó thực sự khó khăn cho bạn như một nhà phát triển phần mềm. Các bug dễ hơn. Bạn có thể trace nó.
You test it and test it. You test it till you find these Bohrbugs. Bohrbugs are easier to find. Okay, pointers — the first big duality you have is an address versus a value, okay?
Bạn test nó và test nó. Bạn test nó cho đến khi tìm thấy những Bohrbugs này. Bohrbugs dễ tìm hơn. Okay, con trỏ — duality lớn đầu tiên mà bạn có là một địa chỉ so với một giá trị, okay?
For now, we're going to live in an abstract world in which all of your memory you're going to have access to and be able to control is one really big array, an infinitely big array.
Bây giờ, chúng ta sẽ sống trong một thế giới trừu tượng trong đó tất cả bộ nhớ của bạn mà bạn sẽ có quyền truy cập và có thể kiểm soát là một mảng thực sự lớn, một mảng vô hạn lớn.
It starts at 0 and goes up to some value. That's it. it goes up to some address, really, I should say. I should use the right terms.
Nó bắt đầu từ 0 và tăng lên một giá trị nào đó. Chỉ có thế. nó đi tới một địa chỉ nào đó, hay đúng hơn là tôi nên nói. Tôi nên dùng đúng thuật ngữ.
It goes up to some address. Each cell has a value, the guy inside the cell, and has an address, the address of the cell.
Nó đi tới một địa chỉ nào đó. Mỗi ô nhớ có một giá trị, cái bên trong ô, và có một địa chỉ, địa chỉ của ô đó.
Like a house, house has an address, and house has a contents, has the value, okay?
Giống như một căn nhà, căn nhà có địa chỉ, và căn nhà có nội dung, có giá trị, được không?
Because we start from 0, does it make sense to use ints signed or unsigned numbers as your addressing mode? You're right.
Vì chúng ta bắt đầu từ 0, có hợp lý không khi dùng các số nguyên có dấu hay không dấu làm chế độ địa chỉ của bạn? Bạn nói đúng.
It doesn't make sense to use a signed number because you don't have negative addresses. So don't confuse an address with the value. But now, think of it as an infinitely large array.
Không hợp lý khi dùng số có dấu vì bạn không có địa chỉ âm. Vì vậy đừng nhầm lẫn địa chỉ với giá trị. Nhưng bây giờ, hãy coi nó như một mảng vô hạn.
Everything's free and wild. It'll get more constrained and more painful later. But for now, they're free and wild. Hey!
Mọi thứ tự do và hoang dã. Nó sẽ bị ràng buộc hơn và đau thương hơn sau. Nhưng bây giờ, chúng tự do và hoang dã. Này!
The '60s, free and wild, everything's great. Infinite array, go crazy. Here's an example, this picture — this picture here on the right.
Những năm '60, tự do và hoang dã, mọi thứ tuyệt vời. Mảng vô hạn, hãy sáng tạo. Dưới đây là một ví dụ, bức ảnh này — bức ảnh ở bên phải này.
If I can show you, if I can get this pen to work, these are addresses, 101 through 105. These are your values, 104.
Nếu tôi có thể cho bạn xem, nếu tôi có thể làm cho cây viết này hoạt động, đây là những địa chỉ, 101 đến 105. Đây là những giá trị của bạn, 104.
So the house at 104 holds the value 23, okay? So for now, understand that. I have another house holding 42 somewhere longer down there, okay?
Vậy ngôi nhà ở địa chỉ 104 chứa giá trị 23, được không? Vì vậy, bây giờ hãy hiểu điều đó. Tôi có một ngôi nhà khác chứa 42 ở đâu đó xa hơn. được không?
A pointer — a pointer is a cell whose value is somebody else's address. That simple. That's it. Simple as that.
Một con trỏ — con trỏ là một ô nhớ có giá trị là địa chỉ của ô nhớ khác. Đơn giản như vậy. Chỉ có vậy. Đơn giản như thế.
Pointer, we say, points to that address. So we'll actually have a picture for that. So there's my locations up top — 101 through 105.
Con trỏ, chúng ta nói, trỏ đến địa chỉ đó. Vậy chúng ta sẽ thực sự có một hình ảnh cho điều đó. Vậy đây là các vị trí ở trên — 101 đến 105.
My names, I even have some names there, x and y. What's x's address? 104. What's x's value?
Những tên của tôi, tôi thậm chí còn có một số tên ở đó, x và y. Địa chỉ của x là gì? 104. Giá trị của x là gì?
23. I'm going to make a new guy. Oh, I have a new variable. I don't know where it lives.
23. Tôi sẽ tạo một biến mới. Ồ, tôi có một biến mới rồi. Tôi không biết nó nằm ở đâu.
I don't know its address. But for p to point to x and to have access to x, means what should be in p's cell? Anybody? Anyone?
Tôi không biết địa chỉ của nó. Nhưng để p trỏ tới x và có thể truy cập x, thì phải có gì trong ô của p? Ai có ý kiến? Có ai?
Buehler? That's right, 104. So if p points to x, it means that x's address is in p's cell or is p's value, okay? Not so hard.
Buehler? Đúng rồi, 104. Vậy nếu p trỏ tới x, nghĩa là địa chỉ của x nằm trong ô của p hoặc là giá trị của p, được chứ? Không khó lắm.
Here's some syntax. So the way I declare and tell C that p is going to be a pointer, it's going to be. It's an integer. It's a pointer to an integer.
Đây là một số cú pháp. Vậy cách tôi khai báo và bảo C rằng p sẽ là một con trỏ, nó sẽ là. Nó là một số nguyên. Nó là con trỏ chỉ tới một số nguyên.
That's what it says. It says that I am now going to hold a box. And the box — I'm going to have a value inside of. I'm going to live somewhere.
Đó là ý nghĩa của nó. Nó nói rằng tôi bây giờ sẽ có một ô. Và ô này — tôi sẽ có một giá trị bên trong. tôi sẽ ở đâu đó.
And the value inside of me, that value, if I were to follow it, is going to be an integer in that location. That's what that says. P points to an integer.
Và giá trị bên trong tôi, giá trị đó, nếu tôi theo nó, sẽ là một số nguyên ở vị trí đó. Đó là ý nghĩa của nó. P chỉ tới một số nguyên.
The next line says that p equals address of y. I say, don't you say ampersand? No. P equals address of y.
Dòng tiếp theo nói rằng p bằng địa chỉ của y. Tôi hỏi, bạn có nói ký hiệu ampersand không? Không. P bằng địa chỉ của y.
Read that as address of y. P now — if p has — by the way, the first slide, what the goal? What's p store after that first line?
Đọc nó là địa chỉ của y. P bây giờ — nếu p có — nhân tiện, slide đầu tiên, mục tiêu là gì? P lưu trữ cái gì sau dòng đầu tiên đó?
Garbage. It's a box. It had garbage inside of it. Remember a line ago, it had garbage in that side of the box.
Dữ liệu rác. Đó là một ô. Nó có dữ liệu rác bên trong. Nhớ lại một dòng trước, nó có dữ liệu rác ở phía đó của ô.
I showed it as blank. it was really garbage. P equals address of y says, ah, p's going to now get the address of y, and put it in p's value.
Tôi vẽ nó trống. nhưng thực ra là dữ liệu rác. P bằng địa chỉ của y nói là, à, p sắp sẽ nhận địa chỉ của y và đặt nó vào giá trị của p.
Now how do you use it? Well, star has this overloaded idea. So if you're declaring it, star says to the C compiler, I'm going to make this a pointer.
Vậy bạn sử dụng nó như thế nào? Vâng, dấu sao có ý tưởng quá tải này. Vì vậy nếu bạn đang khai báo nó, dấu sao nói với trình biên dịch C, Tôi sẽ làm cho nó trở thành một con trỏ.
But if I'm using it and I want to get — I say, I got pointer p, I want to follow the pointer to get whatever value is behind it.
Nhưng nếu tôi sử dụng nó và tôi muốn lấy — Tôi nói, tôi có con trỏ p, tôi muốn theo con trỏ để lấy bất kỳ giá trị nào phía sau nó.
then you're going to say star p again. You're going to say star p again. By the way, that star p could be on the left side or the right-hand side of the equal sign.
Thì bạn sẽ nói star p lần nữa. Bạn sẽ nói star p lần nữa. Nhân tiện, cái star p đó có thể ở phía bên trái hoặc phía bên phải của dấu bằng.
If it's on the right-hand side of the equal sign, as it is here, it's getting the value out of it and storing it in z.
Nếu nó ở phía bên phải của dấu bằng, như ở đây, nó đang lấy giá trị ra khỏi nó và lưu trữ nó trong z.
You could have swapped that and said star p equals z, which, it had z's value across the equal sign and stuff it in wherever p — not into p — wherever p is pointing to, which is here, y.
Bạn có thể hoán đổi điều đó và nói star p bằng z, cái mà, nó có giá trị của z qua dấu bằng và nhét nó vào nơi mà p trỏ tới — không phải vào p — nơi mà p trỏ tới đó là đây, y.
Y would have gotten a new value. Y would have gotten z out of that, okay? By the way, that's called dereferencing. So that's really important.
Y sẽ có một giá trị mới. Y sẽ lấy được z từ cái đó, được chứ? Nhân tiện, cái đó gọi là phát biểu tham chiếu. Vậy đó là điều thực sự quan trọng.
That's the dereference operator. So let's see this actually a piece of code. Let's do this. So int star p and x.
Đó là toán tử phát biểu tham chiếu. Vậy hãy xem cái này là một đoạn code thực tế. Hãy làm cái này. Vậy int star p và x.
What are x contain? Garbage. Exactly right — nothing. We have no idea, okay?
X chứa gì? Rác. Chính xác — không có gì. Chúng ta không biết gì cả, được chứ?
X equals 3. Well, now, I know x's box — x's value is 3.
X bằng 3. Được rồi, bây giờ, tôi biết hộp của x — giá trị của x là 3.
If I say, p equals address of x, what I love about this picture here on the right is that I don't actually care where x lives. You shouldn't need to care where x lives.
Nếu tôi nói p bằng địa chỉ của x, điều tôi thích ở bức tranh này ở bên phải là tôi không thực sự quan tâm x nằm ở đâu. Bạn không cần quan tâm x nằm ở đâu.
Wherever x lives, p now can get to it. That's what's really nice. So it'll be the address. I don't really care what it is.
Bất kể x nằm ở đâu, p giờ đây có thể truy cập nó. Đó là điều thực sự hay. Vậy đó sẽ là địa chỉ. Tôi không thực sự quan tâm nó là gì.
Is it 5? Is it 27? Is it a million? Who cares?
Nó là 5 sao? Nó là 27 sao? Nó là một triệu sao? Ai mà quan tâm?
It just knows that p can connect to x, and get its value, and write x's value for it. It's kind of nice. It's like giving someone your key to your house.
Nó chỉ biết rằng p có thể kết nối với x, và lấy giá trị của nó, và viết giá trị của x cho nó. Nó khá hay. Giống như là bạn đang cho ai đó chìa khóa nhà của bạn.
They can now get in and do your thing there. Pretty cool. How do you get the value of it? Here's how you get the value of it.
Họ có thể vào nhà và làm việc của bạn ở đó. Khá hay đó. Làm sao bạn lấy được giá trị của nó? Đây là cách để lấy giá trị của nó.
So I just showed you this on the previous slide. There's actually a line of C code p points to.
Tôi vừa cho các bạn thấy điều này trên slide trước. Thực tế có một dòng mã C mà p trỏ tới.
And now, star percent d says treat it as a signed integer, and say, go follow it, and say, it's going to be 3 because star p is now kind of the same as x.
Và bây giờ, star percent d nói hãy coi nó là một số nguyên có dấu, và nói, hãy theo nó, và nói, nó sẽ là 3 vì bây giờ star p cũng giống như x.
So if you see star p, you can kind of think of as x, actually, the same way — kind of neat.
Vì vậy nếu bạn thấy star p, bạn có thể nghĩ về nó như là x, thực tế là, cùng một cách — khá gọn gàng.
And again, as I mentioned before, the star is being used in two different ways here.
Và một lần nữa, như tôi đã đề cập trước đó, star được sử dụng theo hai cách khác nhau ở đây.
It's being used both to declare p as a pointer to an integer, and it's being used to dereference it as well. So how to change a value a variable pointed to?
Nó được sử dụng vừa để khai báo p là một con trỏ tới một số nguyên, và nó cũng được dùng để dereference nó. Vậy làm thế nào để thay đổi giá trị của một biến được trỏ tới?
Well, you can use the reference in front of the equal sign. So here's this p. And now, star p equals 5.
Bạn có thể dùng tham chiếu phía trước dấu bằng. Vậy đây là con trỏ p. Và bây giờ, star p bằng 5.
And this is — I mean, I'm going slowly through something I said before. But guess what?
Và cái này — tôi đang đi từng bước qua cái tôi đã nói trước. Nhưng bạn đoán xem?
Now, x's is value got five because I followed it — this is the example of having star p on the left-hand side of the equal sign. Nothing special there.
Bây giờ, giá trị của x là 5 vì tôi theo dõi nó — đây là ví dụ về việc dùng star p ở phía bên trái dấu bằng. Không có gì đặc biệt ở đây.
So now, we can use pointers. Let's turn to something really cool. I want to add one. I have y here at the higher level.
Vậy bây giờ, chúng ta có thể dùng con trỏ. Hãy chuyển sang cái gì đó thực sự hay. Tôi muốn cộng thêm một. Tôi có y ở mức cao hơn.
Maybe it's at the main level or global level. Probably a main. I'll just say, I have a main. And I've got y bound as 3.
Có thể nó ở mức main hoặc mức global. Có thể là một main. Tôi sẽ chỉ nói, tôi có một main. Và tôi có y được gán giá trị 3.
And now, I got this addOne guy, and I want to change what y is. So I'm going to call addOne of y, and I want y to have a new value.
Và bây giờ, tôi có đứa này addOne, và tôi muốn thay đổi y. Vậy tôi sẽ gọi addOne của y, và tôi muốn y có một giá trị mới.
Does y have a new value? Let's see. Is y 4? And — [MUMBLES] yeah, y is still 3.
Có phải y có một giá trị mới không? Hãy xem. y bằng 4 phải không? Và — [MUMBLES] đúng vậy, y vẫn là 3.
Why is that? Because C and Java are passed by value. The system says, oh, here's addOne of y. the systems says, hey, y, what's your value?
Tại sao lại vậy? Vì C và Java được truyền theo giá trị. Hệ thống nói, ồ, đây là addOne của y. hệ thống nói, này, y, giá trị của bạn là gì?
Y says, I'm 3 before you called me. I mean, in the call right before addOne, I was 3, so 3. And only 3 gets transferred to x. X has no connection with y.
Y nói, tôi là 3 trước khi bạn gọi tôi. Ý tôi là, trong lời gọi ngay trước addOne, tôi là 3, nên là 3. Và chỉ có 3 được truyền đến x. X không có liên kết gì với y.
So now x is 3. Local variable x is 3. The local variable x becomes 4. When it's all done, y doesn't change.
Vì vậy bây giờ x là 3. Biến cục bộ x là 3. Biến cục bộ x trở thành 4. Khi tất cả xong, y không thay đổi.
That x changed. They're do different guys, and y stays the same.
Cái x thì thay đổi. Họ là hai anh chàng khác nhau, và y vẫn giữ nguyên.
So I got to figure out a way — boy, I wish I knew a way using the things I just kind of learned on this slide or two ago to change y at the top level by a subroutine, addOne.
Vì vậy tôi phải tìm ra cách — thôi nào, Tôi ước gì tôi biết một cách dùng những thứ tôi vừa học trên slide hay hai slide trước để thay đổi y ở cấp cao nhất bằng một subroutine, addOne.
Boy, I wonder how to change addOne. Hmm. Pointers. So now, watch this.
Mình tự hỏi làm sao để thay đổi addOne. Hmm. Con trỏ. Thế này, bạn xem nhé.
Watch and learn. AddOne, I don't pass in y because that just passes in the 3. I want to pass in the address. Remember, the 123, whatever the address of y is?
Nhìn và học. AddOne, mình không truyền vào y vì cách đó chỉ truyền vào số 3 thôi. Mình muốn truyền vào địa chỉ. Nhớ lại, 123, bất kể địa chỉ của y là gì?
I want to pass that in. And I have to declare the argument of addOne to be a pointer. And now, it's receiving the address.
Mình muốn truyền cái đó vào. Và mình phải khai báo tham số của addOne là một con trỏ. Và bây giờ, nó đang nhận địa chỉ.
So now, in fact, the two guys — I have two. I have y, and I have a pointer. But it's in the subroutine now. So my subroutine can get access to y.
Vậy là, thực tế, hai tên này — Mình có hai tên. Tôi có y, và tôi có một con trỏ. Nhưng bây giờ nó đang ở trong subroutine. Vì vậy subroutine của tôi có thể truy cập y.
And by saying star p equals star p plus 1 grabs the value of y.
Và bằng cách nói star p equals star p plus 1 lấy giá trị của y.
It was 3. it gets a 4 plus 1 is 4 — stuffs it back into y, follows the pointer, stuffs it back into y. Look at that.
Nó là 3. nó được 4 cộng 1 là 4 — đưa nó trở lại vào y, theo con trỏ, đưa nó trở lại vào y. Nhìn kia.
Int y is 3 at the end of that program. Y is now 4. Do a little shimmy. Pretty cool, all right?
Int y là 3 ở cuối chương trình đó. Y bây giờ là 4. Làm một điệu nhảy nhỏ. Khá tuyệt vời, phải không?
So that's how you can change a value at the top level by using a subroutine. But you got to use pointers for that — pretty cool. Danger, danger, Will Robinson.
Vì vậy đó là cách bạn có thể thay đổi một giá trị ở mức cao nhất bằng cách sử dụng một subroutine. Nhưng bạn phải sử dụng con trỏ cho điều đó — khá tuyệt vời. Nguy hiểm, nguy hiểm, Will Robinson.
So the problem that you might have guessed is that that whole initialization to garbage thing is going to come up and give us trouble because local variables are not initialized.
Vậy nên vấn đề mà có lẽ các bạn đã đoán ra là cả quá trình khởi tạo thành rác sẽ gây ra rắc rối cho chúng ta bởi vì các biến cục bộ không được khởi tạo.
They're garbage, right? So look at this. In star p, here's a box, right? Pointer.
Chúng là rác, phải không? Vậy hãy nhìn cái này. Ở star p, đây là một hộp, phải không? Pointers.
It's our int star pointer. Here's a box, pointer. What's inside of it? I don't know.
Đó là int star pointer của chúng ta. Đây là một hộp, pointer. Bên trong nó là gì? Tôi không biết.
Nothing. Garbage, which means it's like a live wire. Imagine a power line comes down. It's all zz, zz, zz, zz, zz.
Không có gì. Rác, có nghĩa là nó giống như một sợi dây nóng. Hãy tưởng tượng một đường dây điện bị gãy xuống. Toàn là zz, zz, zz, zz, zz.
It's point to anything. It's anywhere in memory. And what do you do with the next line? Star pointer equals 5.
Nó có thể chỉ tới bất kỳ thứ gì. Nó có thể ở bất kỳ đâu trong bộ nhớ. Và bạn làm gì với dòng tiếp theo? Star pointer bằng 5.
You're taking 5 and following that line, putting anywhere, and stuffing 5 in it. You don't have any control of that memory. You don't have write privilege to write into some part of memory.
Bạn lấy 5 và theo đường dẫn đó, đặt ở bất kỳ đâu, và nhét 5 vào đó. Bạn không có quyền kiểm soát bộ nhớ đó. Bạn không có quyền ghi để ghi vào một phần nào đó của bộ nhớ.
That is a big trouble. That's clearly an error. And so that is a very common error for beginning programmers, that they don't set pointers to point to something.
Đó là một vấn đề lớn. Đó rõ ràng là một lỗi. Và đó là một lỗi rất phổ biến đối với những lập trình viên mới bắt đầu, những người không đặt con trỏ chỉ tới thứ gì đó.
they just kind of follow it. And we're going to see a video.
họ chỉ theo nó mà thôi. Và chúng ta sẽ xem một video.
I'm going to link you to a wonderful video from my colleague, Nick Parlente at Stanford, who made this outstanding Binki pointer video that you'll see this after this.
Tôi sẽ dẫn bạn đến một video tuyệt vời từ đồng nghiệp của tôi, Nick Parlente ở Stanford, người tạo ra video con trỏ Binki xuất sắc này mà bạn sẽ xem sau đây.
So I showed you a lot of danger. I showed you some cool power, right? You can now change the variable up in main in a subroutine.
Vậy tôi đã cho bạn thấy rất nhiều nguy hiểm. Tôi đã cho bạn thấy một số sức mạnh tuyệt vời, phải không? Bây giờ bạn có thể thay đổi biến trong main từ một hàm con.
You couldn't do that before if you didn't have pointers. That's kind of cool. So here's another reason we use pointers. I got a big struct.
Trước đây bạn không thể làm được điều đó nếu không có con trỏ. Điều đó khá tuyệt. Vậy đây là một lý do khác tại sao chúng ta sử dụng con trỏ. Tôi có một struct lớn.
Remember, I showed you how to do a struct a couple of videos ago.
Hãy nhớ, tôi đã chỉ cho bạn cách làm struct vài video trước đây.
So I got this big struct, a lot of data, a big array — shh — I haven't talked about arrays yet — but a lot of data, [IMITATES CRUNCHING] a big one.
Vậy tôi có struct lớn này, rất nhiều dữ liệu, một array lớn — shhh — Tôi chưa nói về mảng — nhưng có rất nhiều dữ liệu, [IMITATES CRUNCHING] một cái lớn.
And I want to pass it to a subroutine to process. Do I copy all the values and give it to you? Isn't it a little cleaner to literally just pass a pointer?
Và tôi muốn truyền nó tới một subroutine để xử lý. Tôi có nên sao chép tất cả các giá trị và gửi nó cho bạn không? Hay chỉ truyền một con trỏ sẽ sạch hơn một chút?
Now, this big thing only has to be stored once in memory. And I pass a link to it, a pointer to it.
Bây giờ, cái lớn này chỉ cần được lưu trữ một lần trong bộ nhớ. Và tôi truyền một liên kết tới nó, một con trỏ tới nó.
And now, you can be reading and writing to it and doing work on it, and averaging it all, playing with it, modifying it — whatever you want to do — normalizing it.
Và bây giờ, bạn có thể đọc và ghi vào nó và làm việc trên nó, và tính trung bình của nó, chơi với nó, sửa đổi nó — bất cứ thứ gì bạn muốn làm — chuẩn hóa nó.
I don't have to pass all the data at once for you to do that. So it's really clean.
Tôi không cần phải truyền tất cả dữ liệu cùng một lúc để bạn có thể làm điều đó. Vì vậy nó thực sự sạch sẽ.
Like, in one — here's a — bloop — here's a lightweight — here's a wafer-thin pointer. And I give it to you, and then the subroutine does that.
Giống như, trong một — đây là — bloop — đây là một con trỏ siêu nhẹ — đây là một con trỏ mỏng manh. Và tôi đưa nó cho bạn, sau đó subroutine sẽ làm điều đó.
Great. It's really nice. So in general, pointers are everybody who works in C does anything that's not non-trivial is doing it with pointers.
Tuyệt vời. Thực sự rất tốt. Vì vậy nói chung, con trỏ là cho tất cả mọi người những người làm việc với C làm bất cứ điều gì không tầm thường đều đang làm việc với con trỏ.
And so you need to be able to be fluent in that and make sure you're not copying huge amounts of data when you call that. Drawbacks — and we're going to see drawbacks.
Và vì vậy bạn cần phải thành thạo và đảm bảo bạn không copy một lượng lớn dữ liệu khi bạn gọi nó. Nhược điểm — và chúng ta sẽ thấy những nhược điểm.
I told you about bugs and pointers.
Tôi đã kể cho bạn về lỗi và con trỏ.
it's bugs and pointers, and bugs and pointers — we're going to show about — I feel like every other slide is, here's how you can shoot yourself in the foot with pointers.
đó là lỗi và con trỏ, và lỗi và con trỏ — chúng ta sẽ chỉ ra về — Tôi cảm thấy như mỗi slide khác là, đây là cách bạn có thể tự làm hại mình với các con trỏ.
Like, it's just really hard. Memory management and pointers are really hard, but they're really powerful.
Thực sự, nó rất khó. Quản lý bộ nhớ và các con trỏ thực sự rất khó, nhưng chúng rất mạnh mẽ.
I mean, having full access to the raw — it's like, as I mentioned before with my analogy, take all the grill stuff off our car, and now, you got an engine.
Ý tôi là, có quyền truy cập toàn bộ vào — nó giống như, như tôi đã đề cập trước đây bằng phép loại suy của tôi, tháo tất cả những thứ ngoài trên xe của chúng ta, và bây giờ, bạn có một cái động cơ.
And that is — wow, look how fast this is. They can tweak it here, and add some carburetor, and add some nitrous. But you can put your finger and lose your finger too.
Và điều đó — ồ, hãy xem nó nhanh như thế nào. Họ có thể điều chỉnh nó ở đây, và thêm một bộ chế hòa khí, và thêm một ít nitrous. Nhưng bạn cũng có thể đặt tay vào và mất ngón tay.
And that's really what C is like. C is just like that engine. It's like a car without any protection of anything. It's like the road is, zoom, zoom.
Và đó chính xác là những gì C giống như vậy. C chỉ đơn giản là giống như chiếc động cơ đó. Nó giống như một chiếc xe mà không có bất kỳ bảo vệ nào cả. Nó giống như con đường vậy, zoom, zoom.
Like your feet are just — if you put your feet down, [MUMBLES].. Bad, okay?
Giống như chân bạn chỉ — nếu bạn để chân xuống, [MUMBLES]... Tệ, được rồi?
So imagine a car — crazy fast, crazy ability to make any change you want if you know what you're doing. If you don't, it can be really dangerous — really, really.
Vậy hãy tưởng tượng một chiếc xe — siêu nhanh, siêu khả năng để thực hiện bất kỳ thay đổi nào bạn muốn nếu bạn biết mình đang làm gì. Nếu bạn không, nó có thể thực sự nguy hiểm — thực sự, thực sự.
No belt, it's just — eh — and it's wide open. You've seen these cars I've seen. Every once in a while, you a car that has three wheels.
Không có dây an toàn, nó chỉ — uh — và nó hoàn toàn mở. Bạn đã thấy những chiếc xe này, tôi đã thấy. Thỉnh thoảng, bạn thấy một chiếc xe chỉ có ba bánh.
I don't know. I'm going rogue. And it's like, the guy is sitting on a motorcycle, but it's a front car in the back in the back.
Tôi không biết. Tôi đi rogue. Và nó giống như, anh chàng đó đang ngồi trên một chiếc xe máy, nhưng nó là một chiếc xe phía trước ở phía sau ở phía sau.
And it's like, he's this close to the road. It's a little too dangerous to me. Flipped over, there's no roll bar.
Và nó giống như, anh ấy sát mặt đất như thế này. Nó hơi nguy hiểm với tôi. Nếu lật ngược, không có thanh bảo vệ.
Okay, that's kind of like what it's like, but even worse without any kind of grill or anything protecting you, all right? Having some fun. We'll see you at the next video.
Được, nó giống như vậy, nhưng còn tệ hơn mà không có lưới bảo vệ hay gì cả, được không? Vui một chút. Hẹn gặp lại ở video 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.