Name: 節。和丹-阿門達里茲一起調試 (Section: Debugging with Dan Armendariz)
Uploaded: 2021-01-14T06:43:03.000Z
Duration: 23 min 24 s

未來進行式

Today we're going to be looking at debugging.

Not only are we going to talk about some techniques,

but also we're going to look at some of the features contained

within the CS50 IDE that allow you to easily debug a program.

在CS50 IDE允許範圍內 您可以輕鬆地調試程序。

>> Just one example of something that can go wrong,

>> 只是一個例子， 東西可以去錯了，

and it's actually something that we've already seen before.

它實際上是什麼 我們已經看到了。

In this case, this is a C program that accepts an integer from the user,

在這種情況下，這是一個C程序 接受來自用戶的整數，

divides it by 2, and provides the output back to the user.

它除以2，並提供了 輸出給用戶。

Now, from what we've seen earlier in lectures,

現在，從我們已經 在前面講課看到，

we know that this will actually cause specific types of division problems

我們知道，這實際上會導致 特定類型的劃分問題

Specifically, it will just throw away anything after the decimal point.

具體而言，它只是扔掉 小數點後的任何東西。

>> Now, we know that this happens to be the case.

>> 現在，我們知道，這 恰好是這種情況。

And if we run it we can confirm our suspicions first by compiling

如果我們運行它，我們可以確認 我們的懷疑首先由編譯

and then by running and entering an odd number.

This is nothing new, but this is actually

an example of a bug that can exist within a larger program that

一個錯誤的例子，可以 在一個較大的程序存在

Even though we know what the issue is, the true crux of the matter

儘管我們知道是什麼問題 是，事情的真正癥結所在

might be trying to identify specifically where the error occurs,

可能會試圖確定 具體在哪裡出現錯誤，

identifying what that problem is, and then fixing it.

確定是什麼問題 是，然後將其固定。

So I provide this as an example of what might be something

因此，我提供這個作為一個例子 的可能是什麼東西

that we already know but can be buried within other elements of the code.

我們已經知道，但可以埋 內的代碼的其他元素。

>> So opening this other source code file as an example,

>> 所以打開這個其他來源 代碼文件作為例子，

this division problem is now part of a larger program.

這種劃分問題是現在 一個較大的程序的一部分。

Still might be a little bit contrived and we

might be able to easily identify it, especially

可能能夠容易地 識別它，特別是

since we were just discussing this, but we

因為我們只是 討論這個，但我們

can figure out that this problem can exist on a larger scale.

可以計算出，這個問題 可在更大的範圍存在。

If I compile this and now run it, enter an odd number,

如果我編譯這個和現在 運行它，輸入一個奇數，

we can see that we don't get precisely the output that we may have expected.

我們可以看到，我們沒有得到準確 我們可能預期的輸出。

In this particular case, we might say that we

在這種特殊情況下， 我們可以說，我們

want to count all the numbers from 1 up to some specific number.

要計算所有的數字 從1到一些具體數目。

And we can see that we have a variety of issues

我們可以看到，我們 有各種各樣的問題

here if we're putting simply 0 and 1 when we provide an input of 5.

在這裡，如果我們把簡單的0和 1時，我們提供的5輸入。

>> So we already know that there's a problem here.

>> 因此，我們已經知道， 有一個問題在這裡。

But we may not know precisely where this issue actually exists.

但是大家可能不知道準確 其中，這個問題確實存在。

Now, one of the ways that we can try to fix this

現在，所述方法之一是 我們可以嘗試解決這個問題

is something that we've already been introduced to,

我們可以只使用它在更大的規模。

On line 14 we have this printf function which

在第14行，我們有這個 printf函數這

allows us to print out the state of various pieces of information.

使我們能夠打印出狀態 的各種信息。

And this is something that you should leverage within your program

to try to figure out exactly what's happening in various lines of code.

要盡量弄清楚到底是什麼 發生在各行代碼。

>> So even if this is not the final output that we actually

>> 因此，即使這不是 我們實際上最終的輸出

want to produce out of this program, we still

might have some debug statements where we

can try to figure out precisely what is happening inside of our code.

可以揣摩正是 正在發生的事情對我們的代碼中。

So in this case I will printf with a debug tag.

因此，在這種情況下，我會 printf輸出調試標籤。

In this case this is just a debug string that I'm

在這種情況下，這僅僅是 我是一個調試字符串

outputting so that it becomes very clear in the output of my code

輸出，使之成為非常 清晰的在我的代碼的輸出

And output here, the number that we have computed.

>> In this case, I might want to know precisely what is happening

>> 在這種情況下，我可能要 確切地知道發生了什麼

before and after some specific computation

so I might use a printf before and after that line of code.

所以我可能之前用的printf 與該行代碼後。

In this case I could even make it a little bit more clear

在這種情況下，我甚至可以使 它一點點清晰

by saying debug before and debug after so

通過之前說的調試 並經過調試等等

that I don't confuse myself with multiple lines that look identical.

我不混淆自己 多行看起來完全相同。

Now, if we recompile this and run it, enter a number like 5 again,

現在，如果我們重新編譯這個和運行 它，再輸入一個數字像5，

we can see that we have now output before and after

我們可以看到，我們有 現在，前後輸出

and find that we have not done a clear division or a clear having

並發現我們沒有做過 分工明確，或明確有

of the number that we actually want to do.

>> Now, in this case, this is not really a clear output.

>> 現在，在這種情況下，這是 不是一個真正的清晰輸出。

It's not really a clear outcome that we want out of this particular program.

這不是一個真正的明確的結果是 我們想從這個特定的程序。

And this is, again, a little bit contrived.

But perhaps one of the things that we could

do if the specification said that we want to divide this by 2

and add 1-- so in other words, we want to round up--

並添加1--因此，在其他 也就是說，我們要舍up--

then we might know that we could do that particular thing in this case.

那麼我們可能會知道，我們可以做 在這種情況下，該特定的東西。

>> Now, here we know that we will be able to add 1 to our halved number.

>> 現在，在這裡，我們知道，我們將 能加1到我們的一半數量。

Let's recompile this and confirm that this

We can see that now before having we have the number 5,

我們現在才看到， 有，我們有5號，

Which, according to our specification, is what we wanted to do.

其中，根據我們的說明書中， 就是我們想做的事。

But if we look at the output here we can see

但是，如果我們看一下 輸出這裡我們可以看到

that we might have another bug altogether, which is

Now again, this is something that we have seen in the past

現在再次，這是一件 我們已經看到在過去

But in this case we also had the benefit of using the printf statement directly

但在這種情況下，我們也有益處 直接使用printf語句的

inside of the for loop to know precisely where that error was occurring.

內部的for循環準確地知道 如該錯誤發生。

>> So printf statements are very useful in helping

>> 所以printf的聲明 在幫助非常有用

you determine where precisely in your source code

And it's also important to realize that as we're writing code,

而且這也是很重要的實現 隨著我們在寫代碼，

we might have assumptions about the state of a program

大家可能都假設 關於一個程序的狀態

or we might have assumptions about what part of the program

或者我們可能有假設 關於什麼是計劃的一部分

When later on as we build on that program

and make it part of a complex and larger program,

並使其一部分 複雜的大型項目，

that we realize that some aspect of that is actually buggy.

我們認識到，某些方面 那其實是馬車。

>> Using printf can really help narrow down and identify

>> 用printf可以真正幫助 縮小並確定

the regions of a program that may not be behaving exactly the way that we

程序的區域可能不 要準確地行為的方式，我們

But there's other tools available as well

但是，還有其他 可用的工具，以及

that allow us to try to figure out where an error is occurring.

這使我們能夠揣摩 出在哪裡發生異常。