1
00:00:00,000 --> 00:00:05,640

2
00:00:05,640 --> 00:00:06,830
>> ಡೌಗ್ LLOYD: ಸರಿ GDB.

3
00:00:06,830 --> 00:00:08,480
ಇದು ನಿಖರವಾಗಿ ಏನು?

4
00:00:08,480 --> 00:00:11,310
ನಿಂತಿರುವ ಆದ್ದರಿಂದ GDB,
ಗ್ನೂ ಡೀಬಗ್ಗರ್,

5
00:00:11,310 --> 00:00:15,040
ನಿಜವಾಗಿಯೂ ನಾಡಿದು ಸಾಧನ ಎಂದು ನಾವು ಮಾಡಬಹುದು
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ದೋಷ ನಮಗೆ ಸಹಾಯ ಮಾಡಲು,

6
00:00:15,040 --> 00:00:18,210
ಅಥವಾ ವಿಷಯಗಳನ್ನು ಅಲ್ಲಿ ಕಂಡುಹಿಡಿಯಲು
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ತಪ್ಪು ಹೋಗುವ.

7
00:00:18,210 --> 00:00:22,590
GDB, ಆಶ್ಚರ್ಯಕರವಾಗಿ ಪ್ರಬಲ ಆದರೆ
ಇದು ಔಟ್ ಪುಟ್ ಮತ್ತು ಪರಸ್ಪರ

8
00:00:22,590 --> 00:00:23,830
ಸ್ವಲ್ಪ ರಹಸ್ಯ ಇರಬಹುದು.

9
00:00:23,830 --> 00:00:28,210
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಆಜ್ಞಾ ಸಾಲು ಉಪಕರಣವಾಗಿರುತ್ತದೆ, ಮತ್ತು
ಇದು ನೀವು ಸಂದೇಶಗಳನ್ನು ಬಹಳಷ್ಟು ಎಸೆಯಲು ಮಾಡಬಹುದು.

10
00:00:28,210 --> 00:00:31,144
ಮತ್ತು ಇದು ರೀತಿಯ ಹಾರ್ಡ್ ಮಾಡಬಹುದು
ನಡೆಯುತ್ತಿದೆ ನಿಖರವಾಗಿ ಯಾವ ಪಾರ್ಸ್.

11
00:00:31,144 --> 00:00:33,560
ಅದೃಷ್ಟವಶಾತ್, ನಾವು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಕ್ರಮಗಳನ್ನು
ನೀವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಸರಿಪಡಿಸಲು

12
00:00:33,560 --> 00:00:36,281
ನೀವು CS50 ಮೂಲಕ ಕೆಲಸ ಎಂದು.

13
00:00:36,281 --> 00:00:39,030
ನೀವು ಚಿತ್ರಾತ್ಮಕ ಬಳಸದೇ ಇದ್ದರೆ
ದೋಷಸೂಚಕವು, ಇದು ನನ್ನ ಸಹೋದ್ಯೋಗಿ ಡಾನ್

14
00:00:39,030 --> 00:00:41,570
Armandarse ಸಾಕಷ್ಟು ಮಾತನಾಡಿದರು
ವೀಡಿಯೊ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಎಂದು

15
00:00:41,570 --> 00:00:44,740
ಇಲ್ಲಿ ಇರಬೇಕು
ಇದೀಗ, ನೀವು ಬೇಕು

16
00:00:44,740 --> 00:00:48,270
ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಬಳಸಲು
ಉಪಕರಣಗಳು GDB ಕೆಲಸ.

17
00:00:48,270 --> 00:00:51,250
ನೀವು CS50 ರಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ
ಐಡಿಇ, ನೀವು ಇದನ್ನು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ.

18
00:00:51,250 --> 00:00:53,550
ಆದರೆ ನೀವು ಇಲ್ಲದಿದ್ದರೆ
CS50 ಐಡಿಇ ಕೆಲಸ,

19
00:00:53,550 --> 00:00:55,750
ಬಹುಶಃ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ
CS50 ಯಂತ್ರ ಆಫ್,

20
00:00:55,750 --> 00:00:58,860
ಅಥವಾ ಇನ್ನೊಂದು ಲಿನಕ್ಸ್ ಆಪರೇಟಿಂಗ್
GDB ವ್ಯವಸ್ಥೆಯ, ಇದು ಸ್ಥಾಪಿಸಿದ

21
00:00:58,860 --> 00:01:00,980
ನೀವು ಬಳಸಬೇಕಾಗಬಹುದು
ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣಗಳನ್ನು.

22
00:01:00,980 --> 00:01:02,860
>> ಮತ್ತು ನಂತರ ನೀವು ಮಾಡಬಹುದು
ಅದು ಇಲ್ಲಿದೆ, ಹಾಗೆ

23
00:01:02,860 --> 00:01:06,280
ಕೇವಲ ಹೇಗೆ ತಿಳಿಯಲು ಉಪಯುಕ್ತ
GDB ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ಕೆಲಸ.

24
00:01:06,280 --> 00:01:09,650
ಆದರೆ ಮತ್ತೆ, ನೀವು ಇಂತಹ
CS50 ಐಡಿಇ ಬಳಸಿಕೊಂಡು, ನೀವು

25
00:01:09,650 --> 00:01:15,400
ಚಿತ್ರಾತ್ಮಕ ದೋಷಸೂಚಕವು ಬಳಸಬಹುದು
ಅದು IDE ರಚಿಸಲ್ಪಟ್ಟಿದೆ.

26
00:01:15,400 --> 00:01:18,750
ಆದ್ದರಿಂದ ವಿಷಯಗಳನ್ನು ಹೋಗುವ ಪಡೆಯಲು
GDB, ಡೀಬಗ್ ಆರಂಭಿಸಲು

27
00:01:18,750 --> 00:01:21,220
ನಿರ್ದಿಷ್ಟ ಪ್ರಕ್ರಿಯೆ
ಪ್ರೋಗ್ರಾಂ, ನೀವು ಮಾಡಬೇಕು ಎಲ್ಲಾ ಅಗತ್ಯವಿದೆ

28
00:01:21,220 --> 00:01:23,810
GDB ನಂತರ ವಿಧ
ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು.

29
00:01:23,810 --> 00:01:28,620
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವೇಳೆ
ಹಲೋ, ನೀವು GDB ಹಲೋ ಟೈಪ್ ಎಂದು.

30
00:01:28,620 --> 00:01:31,210
>> ನೀವು ಹಾಗೆ ಮಾಡಿದಾಗ, ನೀವು ನೀನು
GDB ಪರಿಸರ ಮೇಲೆಳೆದುಕೊಳ್ಳಲು.

31
00:01:31,210 --> 00:01:33,800
ನಿಮ್ಮ ಕೇಳುತ್ತದೆ, ಮತ್ತು
ಬದಲಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಅದರ

32
00:01:33,800 --> 00:01:35,841
ನೀವು ವಿಷಯಗಳನ್ನು ಟೈಪ್ ಆಗಿದೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಕರಗಳು ನಲ್ಲಿ,

33
00:01:35,841 --> 00:01:38,115
ನಿಮ್ಮ ವಿಶಿಷ್ಟ ಎಲ್ಲಾ cd--
ಲಿನಕ್ಸ್ ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ ಆಜ್ಞೆಗಳನ್ನು

34
00:01:38,115 --> 00:01:42,200
ಬಹುಶಃ, ಏನೋ ಬದಲಾಗುತ್ತದೆ
ಆವರಣ ರೀತಿಯ GDB ಆವರಣ.

35
00:01:42,200 --> 00:01:46,630
ಏಕೆಂದರೆ, ನಿಮ್ಮ ಹೊಸ GDB ​​ಪ್ರಾಂಪ್ಟ್ ಇಲ್ಲಿದೆ
ನೀವು GDB ಪರಿಸರ ಒಳಗೆ ಆರ್.

36
00:01:46,630 --> 00:01:49,830
ಒಮ್ಮೆ ಆ ಪರಿಸರದ ಒಳಗೆ,
ಎರಡು ಪ್ರಮುಖ ಆಜ್ಞೆಗಳನ್ನು ಇಲ್ಲ

37
00:01:49,830 --> 00:01:52,290
ನೀವು ಬಹುಶಃ ಬಳಸಿ
ಈ ಕ್ರಮದಲ್ಲಿ.

38
00:01:52,290 --> 00:01:55,200
>> ಮೊದಲ ಬಿ, ಇದು
ವಿರಾಮದ ಚಿಕ್ಕದಾಗಿದೆ.

39
00:01:55,200 --> 00:01:58,690
ಮತ್ತು ನೀವು ಬಿ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಟೈಪ್ ನಂತರ
ಒಂದು ಕ್ರಿಯೆಯ ಹೆಸರು ಟೈಪ್

40
00:01:58,690 --> 00:02:01,040
ಅಥವಾ ನಿಮಗೆ ಸಂಭವಿಸಿದಾಗ
ಸಾಲು ಸಂಖ್ಯೆ ಸುಮಾರು

41
00:02:01,040 --> 00:02:04,100
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭದಿಂದಲೂ
ಸ್ವಲ್ಪ ವಿಯರ್ಡ್ ವರ್ತಿಸುವಂತೆ,

42
00:02:04,100 --> 00:02:06,370
ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಟೈಪಿಸಿದರೆ
ಸಂಖ್ಯೆಯ ಹಾಗೂ.

43
00:02:06,370 --> 00:02:09,660
ಬಿ, ಅಥವಾ ಬ್ರೇಕ್, ಮಾಡುತ್ತದೆ
ಇದು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನುಮತಿಸುತ್ತದೆ

44
00:02:09,660 --> 00:02:13,270
ಒಂದು ಕೆಲವು ಪಾಯಿಂಟ್ ವರೆಗೂ ಚಲಾಯಿಸಲು,
ಕ್ರಿಯೆಯ ಅಂದರೆ, ಹೆಸರು

45
00:02:13,270 --> 00:02:15,880
ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಥವಾ ಲೈನ್
ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಸಂಖ್ಯೆ.

46
00:02:15,880 --> 00:02:18,590
>> ಮತ್ತು ಆ ಸಮಯದಲ್ಲಿ, ಇದು
ಮರಣದಂಡನೆ ಫ್ರೀಜ್.

47
00:02:18,590 --> 00:02:21,670
ಈ ಕಾರಣ, ಒಳ್ಳೆಯ ವಿಷಯ
ಮರಣದಂಡನೆ ಸ್ಥಗಿತಗೊಂಡಿದೆ ಒಮ್ಮೆ

48
00:02:21,670 --> 00:02:25,214
ನೀವು ಬಹಳ ನಿಧಾನವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ಹೆಜ್ಜೆ.

49
00:02:25,214 --> 00:02:28,130
ನೀವು ಇಲ್ಲಿಗೆ ವೇಳೆ ಸಾಮಾನ್ಯವಾಗಿ, ಚಾಲನೆಯಲ್ಲಿರುವ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು, ಅವರು ಬಹಳ ಸಣ್ಣ ಆರ್.

50
00:02:28,130 --> 00:02:31,250
ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ಡಾಟ್ ಕತ್ತರಿಸಿ ಟೈಪ್ ಯಾವುದೇ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು, ನಮೂದಿಸಿ ಹಿಟ್ ಇದೆ

51
00:02:31,250 --> 00:02:33,470
ಮತ್ತು ನೀವು ಮಿನುಗು ಮೊದಲು, ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ ಈಗಾಗಲೇ ಮುಗಿದ.

52
00:02:33,470 --> 00:02:36,620
ಇದು ನಿಜವಾಗಿಯೂ ಪ್ರಯತ್ನಿಸಿ ಸಾಕಷ್ಟು ಸಮಯ ಅಲ್ಲ
ಮತ್ತು ತಪ್ಪು ವಿಶೇಷವೇನು ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ.

53
00:02:36,620 --> 00:02:40,920
ಇದು ನಿಜವಾಗಿಯೂ ವಿಷಯಗಳನ್ನು ನಿಧಾನಗೊಳಿಸುವ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಆದ್ದರಿಂದ
ಕೆಳಗೆ ಬಿ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್ ಮೂಲಕ

54
00:02:40,920 --> 00:02:43,040
ತದನಂತರ ಮೆಟ್ಟಿಲು.

55
00:02:43,040 --> 00:02:46,169
>> ನಿಮ್ಮ ಬ್ರೇಕ್ ಸೆಟ್ ಮಾಡಿದ ನಂತರ ಒಮ್ಮೆ
ಬಿಂದು, ನೀವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು.

56
00:02:46,169 --> 00:02:47,960
ಮತ್ತು ನೀವು ಯಾವುದೇ ಹೊಂದಿದ್ದರೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು,

57
00:02:47,960 --> 00:02:51,610
ನೀವು ಅವುಗಳನ್ನು ಇಲ್ಲಿ ಸೂಚಿಸಲು ಮಾಡಿದಾಗ
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ರೀತಿಯ GDB.

58
00:02:51,610 --> 00:02:55,980
ನೀವು ಎಲ್ಲಾ ಆಜ್ಞಾ ಸಾಲಿನ ಸೂಚಿಸಿ
ಆರ್, ಅಥವಾ ರನ್ ತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಚರ್ಚೆ

59
00:02:55,980 --> 00:03:00,270
ತದನಂತರ ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು
ನೀವು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಳಗೆ ಅಗತ್ಯವಿದೆ.

60
00:03:00,270 --> 00:03:03,510
ಇತರ ಹಲವಾರು ನಿಜವಾಗಿಯೂ ಇವೆ
ಪ್ರಮುಖ ಮತ್ತು ಉಪಯುಕ್ತ ಆಜ್ಞೆಗಳನ್ನು

61
00:03:03,510 --> 00:03:04,970
ಜಿಡಿಪಿ ಪರಿಸರದ ಒಳಗೆ.

62
00:03:04,970 --> 00:03:07,540
ಆದ್ದರಿಂದ ಕೇವಲ ತ್ವರಿತವಾಗಿ ನನಗೆ ಅವಕಾಶ
ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಹೋಗಿ.

63
00:03:07,540 --> 00:03:11,320
>> ಮೊದಲ, ಮುಂದಿನ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಎನ್, ಆಗಿದೆ
ಮತ್ತು ನೀವು ಮುಂದಿನ ಬದಲಿಗೆ n ನ ಟೈಪಿಸಿದರೆ

64
00:03:11,320 --> 00:03:12,304
ಎರಡೂ ಕೆಲಸ.

65
00:03:12,304 --> 00:03:13,470
ಮತ್ತು ಇದು ಕೇವಲ ಸಂಕ್ಷಿಪ್ತ ಇಲ್ಲಿದೆ.

66
00:03:13,470 --> 00:03:17,540
ಮತ್ತು ನೀವು ಬಹುಶಃ ಈಗಾಗಲೇ ಪಡೆದ ಎಂದು
ವಿಷಯಗಳನ್ನು ಟೈಪ್ ಸಾಧ್ಯವಾಗದ, ಬಳಸಲಾಗುತ್ತದೆ

67
00:03:17,540 --> 00:03:20,520
ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮ.

68
00:03:20,520 --> 00:03:24,100
ಮತ್ತು ಏನು ಮಾಡುತ್ತಾನೆ ಇದು ಮಾಡುತ್ತೇವೆ
ಕೋಡ್ ಮುಂದೆ ಒಂದು ಬ್ಲಾಕ್ ಹೆಜ್ಜೆ.

69
00:03:24,100 --> 00:03:26,170
ಆದ್ದರಿಂದ ಮುಂದುವರೆಯಲು ಮಾಡುತ್ತೇವೆ
ಒಂದು ಕಾರ್ಯ ಕರೆ ರವರೆಗೆ.

70
00:03:26,170 --> 00:03:28,350
ತದನಂತರ ಬದಲಿಗೆ
ಆ ಕಾರ್ಯವನ್ನು ಒಳಗೆ ಡೈವಿಂಗ್

71
00:03:28,350 --> 00:03:33,130
ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗುವ
ಕೋಡ್, ಇದು ಕಾರ್ಯ ಹೊಂದಿರುತ್ತದೆ.

72
00:03:33,130 --> 00:03:34,400
>> ಕಾರ್ಯ ಎಂದು ನಡೆಯಲಿದೆ.

73
00:03:34,400 --> 00:03:35,733
ಇದು ತನ್ನ ಕೆಲಸವನ್ನು ಯಾವುದೇ ಮಾಡುತ್ತೇನೆ.

74
00:03:35,733 --> 00:03:38,870
ಇದು ಈ ಕೆಳಗಿನ ಹಿಂದಿರುಗುವ
ಇದು ಎಂಬ ಕ್ರಿಯೆಯ.

75
00:03:38,870 --> 00:03:42,490
ತದನಂತರ ನೀವು ಕಡೆಗೆ ಮಾಡುತ್ತೇವೆ
ಕರೆ ಕಾರ್ಯದ ಮುಂದಿನ ಸಾಲಿನ.

76
00:03:42,490 --> 00:03:44,555
ನೀವು ಹಂತ ಬಯಸಿದರೆ
ಕಾರ್ಯದ ಒಳಗೆ,

77
00:03:44,555 --> 00:03:46,430
ಬದಲಿಗೆ ಕೇವಲ ಹೊಂದುವ
ಇದು ವಿಶೇಷವಾಗಿ, ಕಾರ್ಯಗತಗೊಳಿಸಲು

78
00:03:46,430 --> 00:03:50,004
ನೀವು ಸಮಸ್ಯೆ ಅನಿಸಿದರೆ
ಕಾರ್ಯದ ಒಳಗೆ ಸುಳ್ಳು ಇರಬಹುದು,

79
00:03:50,004 --> 00:03:52,670
ನೀವು, ಸಹಜವಾಗಿ, ವಿರಾಮ ಹೊಂದಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಒಳಗೆ ಕ್ರಿಯೆಯ ಪಾಯಿಂಟ್.

80
00:03:52,670 --> 00:03:57,820
ನೀವು ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಳಸುತ್ತಿದ್ದರೆ ಅಥವಾ ನೀವು
ಕೋಡ್ ಮುಂದೆ ಒಂದು ಸಾಲಿನ ಸ್ಟೆಪ್ ಬಳಸಲು.

81
00:03:57,820 --> 00:04:01,170
>> ಆದ್ದರಿಂದ ಈ ಹೆಜ್ಜೆ ಕಾಣಿಸುತ್ತದೆ
ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಡೈವ್,

82
00:04:01,170 --> 00:04:04,750
ಬದಲಿಗೆ ಕೇವಲ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೊಂದಿವೆ
ಮತ್ತು ಕಾರ್ಯದಲ್ಲಿ ಮುಂದುವರೆಯುತ್ತಿದೆ

83
00:04:04,750 --> 00:04:07,380
ನೀವು ಡೀಬಗ್ ಆರ್.

84
00:04:07,380 --> 00:04:09,870
ನೀವು ಎಂದಾದರೂ ತಿಳಿಯಲು ಬಯಸಿದರೆ
ಒಂದು ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು,

85
00:04:09,870 --> 00:04:12,507
ನೀವು ಪು, ಅಥವಾ ಪ್ರಿಂಟ್ ಟೈಪ್ ಮಾಡಬಹುದು
ತದನಂತರ ವೇರಿಯಬಲ್ ಹೆಸರು.

86
00:04:12,507 --> 00:04:15,090
ಮತ್ತು, ನಿಮಗೆ ಮುದ್ರಿಸುತ್ತದೆ
GDB ಪರಿಸರದ ಒಳಗೆ,

87
00:04:15,090 --> 00:04:19,110
ವೇರಿಯಬಲ್ ಹೆಸರು, ಎಂದು you--
ನನಗೆ ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು ಕ್ಷಮಿಸಬೇಕು

88
00:04:19,110 --> 00:04:20,064
ನೀವು ಎಂಬ ಬಂದಿದೆ ಎಂದು.

89
00:04:20,064 --> 00:04:23,230
ನೀವು ಪ್ರತಿ ಮೌಲ್ಯಗಳನ್ನು ತಿಳಿಯಲು ಬಯಸಿದರೆ
ಅಲ್ಲಿ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಪ್ರವೇಶಿಸಬಹುದು

90
00:04:23,230 --> 00:04:25,970
ನೀವು ಪ್ರಸ್ತುತ ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ, ನೀವು ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು ಟೈಪ್ ಮಾಡಬಹುದು.

91
00:04:25,970 --> 00:04:28,332
ಇದು ಹೆಚ್ಚು ಬಹಳಷ್ಟು ವೇಗವಾಗಿ ಇಲ್ಲಿದೆ
ನಂತರ ಪು ಟೈಪ್ ಮತ್ತು ಯಾವುದೇ,

92
00:04:28,332 --> 00:04:30,540
ಎಲ್ಲಾ ಔಟ್ ಪಟ್ಟಿ
ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ತಿಳಿದಿರುವ ಅಸ್ಥಿರ.

93
00:04:30,540 --> 00:04:34,370
ನೀವು ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು ಟೈಪ್, ಮತ್ತು ಇದು ಮಾಡಬಹುದು
ನೀವು ಎಲ್ಲವನ್ನೂ ಮುದ್ರಿಸುತ್ತದೆ.

94
00:04:34,370 --> 00:04:37,770
ಪಕ್ಕದಲ್ಲಿ ಇದು ಬಿಟಿ ಆಗಿದೆ
ಬ್ಯಾಕ್ ಟ್ರೇಸ್ ಸಣ್ಣ.

95
00:04:37,770 --> 00:04:41,680
ಈಗ, ಸಾಮಾನ್ಯವಾಗಿ,
ವಿಶೇಷವಾಗಿ ಆರಂಭಿಕ CS50 ರಲ್ಲಿ,

96
00:04:41,680 --> 00:04:44,450
ನೀವು ನಿಜವಾಗಿಯೂ ಸಂದರ್ಭದಲ್ಲಿ ಬೀರುವುದಿಲ್ಲ
ಬಿಟಿ, ಅಥವಾ ಬ್ಯಾಕ್ ಟ್ರೇಸ್ ಬಳಸಲು,

97
00:04:44,450 --> 00:04:47,860
ನೀವು ಕ್ರಿಯೆಗಳನ್ನು ಪಡೆಯುವುದು ಏಕೆಂದರೆ
ಇತರ ಕಾರ್ಯಗಳನ್ನು ಕರೆ.

98
00:04:47,860 --> 00:04:50,450
>> ನೀವು ಮುಖ್ಯ ಕರೆ ಒಂದು ಹೊಂದಿರಬಹುದು
ಕಾರ್ಯ, ಆದರೆ ಬಹುಶಃ ಅದು ಇಲ್ಲಿದೆ.

99
00:04:50,450 --> 00:04:53,199
ನೀವು ಇತರ ಕಾರ್ಯವನ್ನು ಹೊಂದಿಲ್ಲ,
ಮತ್ತೊಂದು ಕ್ರಿಯೆ, ಕರೆ ಇದು

100
00:04:53,199 --> 00:04:54,880
ಮತ್ತೊಂದು ಕಾರ್ಯ ಕರೆಗಳನ್ನು, ಹೀಗೆ.

101
00:04:54,880 --> 00:04:57,550
ಆದರೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಹೆಚ್ಚು ಪಡೆಯಲು ಎಂದು
ಸಂಕೀರ್ಣ, ಮತ್ತು ವಿಶೇಷವಾಗಿ

102
00:04:57,550 --> 00:05:00,290
ನೀವು ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿದಾಗ
ಪುನರಾವರ್ತನ ಜೊತೆ, ಮತ್ತೆ ಜಾಡಿನ

103
00:05:00,290 --> 00:05:05,150
ನೀವು ಅವಕಾಶ ಒಂದು ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಮಾರ್ಗವಾಗಿದೆ
ರೀತಿಯ ಅಲ್ಲಿ ಕೆಲವು ಸಂದರ್ಭದಲ್ಲಿ ಪಡೆಯಲು

104
00:05:05,150 --> 00:05:06,460
ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾನು.

105
00:05:06,460 --> 00:05:10,590
ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ಕೋಡ್ ಬರೆದು ನಾವು ಹೇಳಲು, ಮತ್ತು
ನೀವು ಮುಖ್ಯ ಒಂದು ಕಾರ್ಯ ಕರೆಗಳನ್ನು ತಿಳಿದಿದೆ

106
00:05:10,590 --> 00:05:14,720
ಒಂದು ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಇದು ಎಫ್,
ಒಂದು ಫಂಕ್ಷನ್ h ಅನ್ನು ಕರೆಯುತ್ತದೆ, ಜಿ.

107
00:05:14,720 --> 00:05:17,650
ನಾವು ಹಲವಾರು ಪದರಗಳು
ಗೂಡುಕಟ್ಟುವ ಇಲ್ಲಿ ನಡೆಯುತ್ತಿರುವ.

108
00:05:17,650 --> 00:05:19,440
>> ನೀವು ಒಳಗೆ ನೀವು
ನಿಮ್ಮ GDB ಪರಿಸರ,

109
00:05:19,440 --> 00:05:21,640
ಮತ್ತು ನಿಮ್ಮ ಒಳಗೆ ಗೊತ್ತು
ಗಂ, ಆದರೆ ನೀವು ಮರೆಯಬೇಡಿ

110
00:05:21,640 --> 00:05:27,210
ನೀವು ಅಲ್ಲಿ ನೀವು ಪಡೆದುಕೊಂಡದ್ದು ಬಗ್ಗೆ
ನೀವು ಬಿಟಿ, ಅಥವಾ ಮತ್ತೆ ಜಾಡಿನ ಟೈಪಿಸಿದರೆ are--,

111
00:05:27,210 --> 00:05:32,370
ಮತ್ತು ಇದು, ಗಂ, ಗ್ರಾಂ ಔಟ್ ಮುಖ್ಯ F ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ
ಕೆಲವು ಮಾಹಿತಿ, ಜೊತೆಗೆ ಇದು

112
00:05:32,370 --> 00:05:35,984
ನೀವು ಒಂದು ಸುಳಿವನ್ನು ನೀಡುತ್ತದೆ, ಸರಿ ಮುಖ್ಯ
ಎಂಬ ಎಫ್ ಎಂಬ ಗ್ರಾಂ ಎಫ್, ಜಿ, ಹೆಚ್ ಎಂಬ

113
00:05:35,984 --> 00:05:37,900
ಮತ್ತು ಅಲ್ಲಿ ನಾನು
ಪ್ರಸ್ತುತ ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾನು.

114
00:05:37,900 --> 00:05:41,380
ಆದ್ದರಿಂದ, ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತವಾಗಿದೆ
ವಿಶೇಷವಾಗಿ GDB ಯ ಗೂಢ ಸೆಲ್ಲೋಫೇನ್ ಎಂದು

115
00:05:41,380 --> 00:05:45,667
ಗೆ, ಸ್ವಲ್ಪ ಅಗಾಧ ಆಗುತ್ತದೆ
ವಸ್ತುಗಳು ನಿಖರವಾಗಿ ಅಲ್ಲಿ ಕಂಡುಹಿಡಿಯಲು.

116
00:05:45,667 --> 00:05:48,500
ಅಂತಿಮವಾಗಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲಾಗುತ್ತದೆ,
ನೀವು ಪೂರೈಸಿದಾಗ ಅಥವಾ ಅದನ್ನು ಡೀಬಗ್

117
00:05:48,500 --> 00:05:50,125
ಮತ್ತು ನೀವು ದೂರ ಹೆಜ್ಜೆ
GDB ಪರಿಸರದಿಂದ,

118
00:05:50,125 --> 00:05:51,940
ಅದು ಹೊರಗೆ ಹೇಗೆ ತಿಳಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

119
00:05:51,940 --> 00:05:55,500
ನೀವು ಪ್ರಶ್ನೆ ಟೈಪ್ ಅಥವಾ ಹೊರಬರಲು, ಬಿಟ್ಟು.

120
00:05:55,500 --> 00:05:59,220
ಈಗ, ಇಂದಿನ ವಿಡಿಯೋ ಮೊದಲು
ನಾನು ಒಂದು ದೋಷಯುಕ್ತ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ತಯಾರಿಸಲಾಗುತ್ತದೆ

121
00:05:59,220 --> 00:06:03,900
ನಾನು ಸಂಕಲನ ಇದು ಎಂಬ buggy1,
buggy1.c ಎಂಬ ಕಡತದಿಂದ.

122
00:06:03,900 --> 00:06:06,500
ನೀವು, ಈ ಅಪೇಕ್ಷಿಸಬಹುದು ಮಾಹಿತಿ
ಪ್ರೋಗ್ರಾಂ ವಾಸ್ತವವಾಗಿ ದೋಷಯುಕ್ತ ಹೊಂದಿದೆ.

123
00:06:06,500 --> 00:06:08,990
ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ
ನಾನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಚಾಲನೆ.

124
00:06:08,990 --> 00:06:13,014
ಈಗ, ದುರದೃಷ್ಟವಶಾತ್, ನಾನು ತಿಳಿಯದೆ
ನನ್ನ buggy1.c ಕಡತ ಅಳಿಸಲಾಗಿದೆ

125
00:06:13,014 --> 00:06:15,930
ಆದ್ದರಿಂದ ಸಲುವಾಗಿ ನನಗೆ ಲೆಕ್ಕಾಚಾರ
ಏನು, ಈ ಪ್ರೋಗ್ರಾಂ ತಪ್ಪು ವಿಶೇಷವೇನು

126
00:06:15,930 --> 00:06:18,770
ನಾನು ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ ಪಡೆಯಲಿದ್ದೇನೆ
GDB ರೀತಿಯ ಕುರುಡಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

127
00:06:18,770 --> 00:06:22,372
ಈ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ನ್ಯಾವಿಗೇಟ್
ತಪ್ಪು ವಿಶೇಷವೇನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ.

128
00:06:22,372 --> 00:06:24,580
ಆದರೆ ಸಾಧನಗಳನ್ನು ಬಳಸುವ
ನಾವು ಈಗಾಗಲೇ ಕಲಿತ

129
00:06:24,580 --> 00:06:27,700
ನಾವು ಅತ್ಯಧಿಕವಾಗಿ ಲೆಕ್ಕಾಚಾರ
ಅದು ನಿಖರವಾಗಿ ಏನೆಂದು.

130
00:06:27,700 --> 00:06:30,740
ಆದ್ದರಿಂದ ಮೇಲೆ ತಲೆಯಿಂದ ಅವಕಾಶ
CS50 ಐಡಿಇ ಮತ್ತು ಒಂದು ನೋಟ ಹೊಂದಿವೆ.

131
00:06:30,740 --> 00:06:33,155
ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ನೀವು ನನ್ನ
CS50 ಐಡಿಇ ಪರಿಸರ,

132
00:06:33,155 --> 00:06:35,697
ಮತ್ತು ನಾನು ಸ್ವಲ್ಪ ಜೂಮ್ ವಿಲ್
ಆದ್ದರಿಂದ ನೀವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ನೋಡಬಹುದು.

133
00:06:35,697 --> 00:06:38,530
ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ, ನಾನು ಪಟ್ಟಿ
ನನ್ನ ಪ್ರಸ್ತುತ ನಿರ್ದೇಶಕ ವಿಷಯಗಳನ್ನು

134
00:06:38,530 --> 00:06:41,250
LS ಹೊಂದಿರುವ, ನಾವು ನಾನು ನೋಡುತ್ತಾರೆ
ಮೂಲ ಕಡತಗಳನ್ನು ಒಂದೆರಡು ಹೊಂದಿವೆ

135
00:06:41,250 --> 00:06:44,982
ಇಲ್ಲಿ, ಸೇರಿದಂತೆ
ಹಿಂದೆ buggy1 ಚರ್ಚಿಸಲಾಗಿದೆ.

136
00:06:44,982 --> 00:06:46,940
ಏನು ಯಾವಾಗ ಹೋಗುತ್ತದೆ
ನಾನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು buggy1 ರನ್.

137
00:06:46,940 --> 00:06:47,773
ಅಲ್ಲದೆ ನ ಔಟ್ ಕಂಡುಹಿಡಿಯೋಣ.

138
00:06:47,773 --> 00:06:52,510
ನಾನು, ಡಾಟ್ ಕತ್ತರಿಸಿ ಟೈಪ್
ದೋಷಯುಕ್ತ, ಮತ್ತು ನಾನು ನಮೂದಿಸಿ ಹಿಟ್.

139
00:06:52,510 --> 00:06:53,670
>> ವಿಭಜನೆ ದೋಷಗಳು.

140
00:06:53,670 --> 00:06:55,000
ಉತ್ತಮ ಅಲ್ಲ.

141
00:06:55,000 --> 00:06:57,180
ನೀವು ಮರುಪಡೆಯಲು ವೇಳೆ, ಒಂದು
ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ವಿಶಿಷ್ಟವಾಗಿ

142
00:06:57,180 --> 00:07:01,540
ನಾವು ಮೆಮೊರಿ ಪ್ರವೇಶಿಸುವಾಗ ಸಂಭವಿಸುವ
ನಾವು ಮುಟ್ಟುವಂತಿಲ್ಲ ನೀವು.

143
00:07:01,540 --> 00:07:03,820
ನಾವು ಹೇಗೋ ತಲುಪಿದ್ದೀರಿ
ಪರಿಧಿಯಿಂದ ಹೊರಗೆ

144
00:07:03,820 --> 00:07:05,995
ಯಾವ ಪ್ರೋಗ್ರಾಂ,
ಕಂಪೈಲರ್, ನಮಗೆ ನೀಡಿದೆ.

145
00:07:05,995 --> 00:07:08,310
ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ಒಂದು
ಸುಳಿವು ಉಪಕರಣ ಇರಿಸಿಕೊಳ್ಳಲು

146
00:07:08,310 --> 00:07:10,660
ನಾವು ಡೀಬಗ್ ಪ್ರಕ್ರಿಯೆ ಆರಂಭಿಸಿದಾಗ.

147
00:07:10,660 --> 00:07:13,620
ಏನೋ ಇಲ್ಲಿ ಸ್ವಲ್ಪ ತಪ್ಪಾಗಿದೆ.

148
00:07:13,620 --> 00:07:15,935
>> ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಆರಂಭ
GDB ಪರಿಸರವನ್ನು

149
00:07:15,935 --> 00:07:19,030
ನಾವು ವ್ಯಕ್ತಿಯು ಒಂದು ವೇಳೆ ಮತ್ತು ನೋಡಿ
ನಿಖರವಾಗಿ ಸಮಸ್ಯೆ.

150
00:07:19,030 --> 00:07:21,674
ನನ್ನ ಪರದೆಯ ತೆರವುಗೊಳಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಮತ್ತು ನಾನು GDB ಟೈಪ್ ಪಡೆಯಲಿದ್ದೇನೆ

151
00:07:21,674 --> 00:07:24,340
ಮತ್ತೆ, GDB ಪರಿಸರಕ್ಕೆ ಪ್ರವೇಶಿಸಲು,
ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು

152
00:07:24,340 --> 00:07:27,450
ನಾನು buggy1 ದೋಷ ಬಯಸುವ.

153
00:07:27,450 --> 00:07:30,182
ನಾವು ಓದುವ, ಸ್ವಲ್ಪ ಸಂದೇಶವನ್ನು
buggy1 ಸಂಕೇತಗಳಿಂದ, ಮಾಡಲಾಗುತ್ತದೆ.

154
00:07:30,182 --> 00:07:32,390
ಅರ್ಥ ಎಲ್ಲಾ ಇದು ಆಕರ್ಷಿಸಲ್ಪಡುತ್ತದೆ
ಒಟ್ಟಿಗೆ ಕೋಡ್ ಎಲ್ಲಾ,

155
00:07:32,390 --> 00:07:35,570
ಈಗ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ
GDB, ಮತ್ತು ಹೋಗಲು ಸಿದ್ಧ.

156
00:07:35,570 --> 00:07:37,140
>> ಈಗ, ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ?

157
00:07:37,140 --> 00:07:39,130
ನೀವು ಏನು ನೆನಪಿದೆಯೇ
ಮೊದಲ ಹಂತದ ವಿಶಿಷ್ಟವಾಗಿ

158
00:07:39,130 --> 00:07:42,540
ನಾನು ಈ ಪರಿಸರದ ಒಳಗೆ ಮನುಷ್ಯ ನಂತರ?

159
00:07:42,540 --> 00:07:44,540
ಆಶಾದಾಯಕವಾಗಿ, ನೀವು ಸೆಟ್ ಹೇಳಿದರು
ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್, ಏಕೆಂದರೆ

160
00:07:44,540 --> 00:07:46,240
ವಾಸ್ತವವಾಗಿ ಎಂದು ನಾನು ಬಯಸುವ ಏನು.

161
00:07:46,240 --> 00:07:47,990
ಈಗ, ನಾನು ಹೊಂದಿಲ್ಲ
ಈ ಮೂಲ ಕೋಡ್

162
00:07:47,990 --> 00:07:50,948
ನನ್ನ ಮುಂದೆ, ಇದು ಬಹುಶಃ
ವಿಶಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂಲಕ.

163
00:07:50,948 --> 00:07:52,055
ನೀವು ಬಹುಶಃ.

164
00:07:52,055 --> 00:07:52,680
ಆ ಉತ್ತಮ ಇಲ್ಲಿದೆ.

165
00:07:52,680 --> 00:07:55,790
ಆದರೆ ಊಹಿಸಿಕೊಂಡು ನೀವು ನಾಟ್, ಇಲ್ಲಿದೆ ಮಾಡಲು
ನಿಮಗೆ ಒಂದು ಕಾರ್ಯ

166
00:07:55,790 --> 00:07:58,880
ಪ್ರತಿಯೊಂದು ಸಿ ಪ್ರೋಗ್ರಾಂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ?

167
00:07:58,880 --> 00:08:04,420
ಎಷ್ಟೇ ದೊಡ್ಡ ಅಥವಾ ಎಷ್ಟು ಸಂಕೀರ್ಣ
ಅದು, ಈ ಕಾರ್ಯ ಖಂಡಿತವಾಗಿಯೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

168
00:08:04,420 --> 00:08:05,440
ಮುಖ್ಯ, ಬಲ?

169
00:08:05,440 --> 00:08:08,870
>> ಆದ್ದರಿಂದ ಬೇರೆ ಎಲ್ಲಾ, ನಾವು ಮಾಡಬಹುದು ವಿಫಲವಾದ
ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್.

170
00:08:08,870 --> 00:08:12,200
ಮತ್ತೆ, ನಾನು ಟೈಪ್ ಮಾಡಬಹುದು
ಬದಲಿಗೆ ಬಿ, ಮುಖ್ಯ ಮುರಿಯಲು.

171
00:08:12,200 --> 00:08:14,650
ಮತ್ತು ನೀವು, ಕುತೂಹಲದಿಂದ, ನೀವು ವೇಳೆ
ಇದುವರೆಗೆ ದೀರ್ಘ ಆಜ್ಞೆಯನ್ನು ಟೈಪ್

172
00:08:14,650 --> 00:08:16,800
ಮತ್ತು ನಂತರ ನೀವು ಅರ್ಥ
ತಪ್ಪು ವಿಷಯ ಟೈಪಿಸಿದ,

173
00:08:16,800 --> 00:08:18,770
ಮತ್ತು ನೀವು ತೊಡೆದುಹಾಕಲು ಬಯಸುವ
ಎಲ್ಲಾ ನಾನು ಮಾಡಿದಂತೆ,

174
00:08:18,770 --> 00:08:22,029
ನೀವು ತಿನ್ನುವೆ, ಕಂಟ್ರೋಲ್ ಯು ತೆಗೆದುಕೊಳ್ಳಬಹುದು
ಎಲ್ಲವನ್ನೂ ಅಳಿಸಿ ಮತ್ತು ನೀವು ತಿಳಿಯಪಡಿಸಲು

175
00:08:22,029 --> 00:08:23,570
ಕರ್ಸರ್ ಸಾಲುಗಳನ್ನು ಆರಂಭಕ್ಕೆ.

176
00:08:23,570 --> 00:08:26,569
ಕೇವಲ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಿ ವೇಗವಾಗಿ ಬಹಳಷ್ಟು
ಅಳಿಸಿ ಅಥವಾ ಒಂದು ಗುಂಪನ್ನು ಬಾರಿ ಹೊಡೆಯುವ

177
00:08:26,569 --> 00:08:27,080
ಮೇಲೆ.

178
00:08:27,080 --> 00:08:28,740
>> ಆದ್ದರಿಂದ ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್ ಮಾಡುತ್ತೇವೆ.

179
00:08:28,740 --> 00:08:32,970
ಮತ್ತು ನೀವು ನೋಡಬಹುದು ಎಂದು, ಇದು ನಾವು ಮಾಡಿದ ಹೇಳುತ್ತಾರೆ
ಕಡತ buggy1.c ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್,

180
00:08:32,970 --> 00:08:36,330
ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ ಮೊದಲ ಸಾಲು
ಮುಖ್ಯ ಕೋಡ್ ಸಾಲಿನ ಏಳು.

181
00:08:36,330 --> 00:08:38,080
ಮತ್ತೆ, ನಾವು ಇಲ್ಲ
ಇಲ್ಲಿ ಮೂಲ ಫೈಲ್,

182
00:08:38,080 --> 00:08:40,429
ಆದರೆ ನಾನು ಎಂದು ಊಹಿಸುತ್ತವೆ ಮಾಡುತ್ತೇವೆ
ನನಗೆ ಸತ್ಯ ಹೇಳುವ.

183
00:08:40,429 --> 00:08:44,510
ತದನಂತರ, ನಾನು ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು
ಮತ್ತು ಆರ್, ಪ್ರೋಗ್ರಾಂ.

184
00:08:44,510 --> 00:08:45,360
ಕಾರ್ಯಕ್ರಮವನ್ನು ಪ್ರಾರಂಭಿಸುವ.

185
00:08:45,360 --> 00:08:48,160
ಸರಿ, ಈ ಸಂದೇಶವನ್ನು
ಒಂದು ಸ್ವಲ್ಪ ರಹಸ್ಯ.

186
00:08:48,160 --> 00:08:50,160
ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಇಲ್ಲಿದೆ
ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಅದು ಕೇವಲ ಆಗಿದೆ

187
00:08:50,160 --> 00:08:53,350
ನನ್ನ ಬ್ರೇಕ್ ಹಿಟ್ ಮಾಡಿದ ನನಗೆ ಹೇಳುವ
ಪಾಯಿಂಟ್, ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆ 1.

188
00:08:53,350 --> 00:08:55,877
>> ತದನಂತರ, ಕೋಡ್ ಆಫ್ ಸಾಲನ್ನು
ಯಾವುದೇ ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿ.

189
00:08:55,877 --> 00:08:57,710
ಕೇವಲ ಕಾರಣದಿಂದ
ನಾನು ಸಂದೇಶವನ್ನು ನೋಡಿದ ಬಾಗುತ್ತೇನೆ

190
00:08:57,710 --> 00:09:00,800
ನಾನು ಅಜಾಗರೂಕತೆಯಿಂದ ಏಕೆಂದರೆ
ನನ್ನ buggy.c ಕಡತ ಅಳಿಸಲಾಗಿದೆ.

191
00:09:00,800 --> 00:09:04,050
ನನ್ನ buggy1.c ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ವೇಳೆ
ಪ್ರಸ್ತುತ ಕೋಶದಲ್ಲಿ

192
00:09:04,050 --> 00:09:06,920
ವಾಸ್ತವವಾಗಿ ಎಂದು ಸಾಲನ್ನು ಬಲ
ಹೇಳಿ ಕೋಡ್ ಸಾಲು

193
00:09:06,920 --> 00:09:08,214
ಅಕ್ಷರಶಃ ಓದುತ್ತದೆ.

194
00:09:08,214 --> 00:09:09,380
ದುರದೃಷ್ಟವಶಾತ್, ನಾನು ಅಳಿಸಲಾಗಿದೆ.

195
00:09:09,380 --> 00:09:14,790
ನಾವು ರೀತಿಯ ನ್ಯಾವಿಗೇಟ್ ನೀನು
ಹೆಚ್ಚು ಕುರುಡಾಗಿ ಈ ಸ್ವಲ್ಪ ಮೂಲಕ.

196
00:09:14,790 --> 00:09:17,330
>> ಸರಿ, ಆದ್ದರಿಂದ ನೋಡೋಣ, ಏನು
ನಾನು ಇಲ್ಲಿ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ?

197
00:09:17,330 --> 00:09:21,770
ನಾನು ಸ್ಥಳೀಯ ಏನು ತಿಳಿಯಲು ಬಯಸುತ್ತೇನೆ
ಅಸ್ಥಿರ ಬಹುಶಃ ನನಗೆ ಲಭ್ಯವಿದೆ.

198
00:09:21,770 --> 00:09:23,570
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭಿಸಿದಾಗ.

199
00:09:23,570 --> 00:09:28,515
ನ ಇರಬಹುದು ಎಂಬುದನ್ನು ನೋಡೋಣ
ಈಗಾಗಲೇ ನಮಗೆ ಆರಂಭಿಸಲಾಗಿಲ್ಲ.

200
00:09:28,515 --> 00:09:31,430
ನಾನು ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು, ಯಾವುದೇ ಸ್ಥಳೀಯರು ಟೈಪ್.

201
00:09:31,430 --> 00:09:33,960
ಎಲ್ಲಾ ಸರಿ, ಆದ್ದರಿಂದ
ನನಗೆ ಮಾಹಿತಿಯನ್ನು ಒಂದು ಟನ್ ನೀಡುತ್ತದೆ.

202
00:09:33,960 --> 00:09:37,600
ನಾನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಒಂದು ವೇರಿಯೇಬಲ್ ಮುದ್ರಿಸುತ್ತದೆ,
ಆದರೆ ನಾನು ಯಾವುದೇ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳು ಗೊತ್ತಿಲ್ಲ.

203
00:09:37,600 --> 00:09:39,930
ನಾನು ಮತ್ತೆ ಜಾಡಿನ ಪ್ರಯತ್ನಿಸಬಹುದು,
ಆದರೆ ನಾನು ಮುಖ್ಯ ಒಳಗೆ ಮನುಷ್ಯ,

204
00:09:39,930 --> 00:09:43,710
ಆದ್ದರಿಂದ ನಾನು ಮಾಡಿಲ್ಲ ಗೊತ್ತು
ಇದೀಗ ಮತ್ತೊಂದು ಕ್ರಿಯೆ ಕರೆ.

205
00:09:43,710 --> 00:09:47,710
>> ನನ್ನ ಮಾತ್ರ ಆಯ್ಕೆಗಳೆಂದರೆ ಹಾಗೆ ಕಾಣುತ್ತದೆ
ಎನ್ ಅಥವಾ ಬಳಸಲು ಮತ್ತು ಧುಮುಕುವುದಿಲ್ಲ ಆರಂಭಿಸಲು.

206
00:09:47,710 --> 00:09:49,630
ನಾನು ಎನ್ ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

207
00:09:49,630 --> 00:09:51,180
ಹಾಗಾಗಿ N ಟೈಪ್.

208
00:09:51,180 --> 00:09:53,060
ದೇವತೆ ನನ್ನ ಓಹ್, ಏನು ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ.

209
00:09:53,060 --> 00:09:56,260
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಸಂಕೇತಗಳನ್ನು ಪಡೆದರು,
SIGSEGV ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ

210
00:09:56,260 --> 00:09:57,880
ತದನಂತರ ವಿಷಯದ ಸಂಪೂರ್ಣ ಗುಂಪೇ.

211
00:09:57,880 --> 00:09:58,880
ನಾನು ಈಗಾಗಲೇ ಚಿತ್ತಸ್ಥೈರ್ಯವು ಮನುಷ್ಯ.

212
00:09:58,880 --> 00:10:00,980
ಅಲ್ಲದೆ, ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ ಒಂದು
ಬಹಳಷ್ಟು ಇಲ್ಲಿ ಕಲಿಯಬೇಕಾದ.

213
00:10:00,980 --> 00:10:02,520
ಹಾಗಾಗಿ ಈ ನಮಗೆ ಹೇಳಲು ಇಲ್ಲ?

214
00:10:02,520 --> 00:10:09,180
ಏನು ಇದು ತಿಳಿಸುತ್ತದೆ ಈ ಕಾರ್ಯಕ್ರಮ, ಆಗಿದೆ
ಸುಮಾರು, ಆದರೆ ಇನ್ನೂ, seg ತಪ್ಪು.

215
00:10:09,180 --> 00:10:12,550
ವಿಶೇಷವಾಗಿ, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
ಮತ್ತಷ್ಟು ಇಲ್ಲಿ ಜೂಮ್,

216
00:10:12,550 --> 00:10:18,980
ಅದರ ಬಗ್ಗೆ seg ತಪ್ಪು ಬಗ್ಗೆ
ಏನೋ strcmp ಕರೆಯಲಾಗುತ್ತದೆ.

217
00:10:18,980 --> 00:10:22,705
>> ಈಗ, ನಾವು ಚರ್ಚಿಸಲಾಗಿದೆ ಇರಬಹುದು
ವ್ಯಾಪಕವಾಗಿ ಈ ಕಾರ್ಯ.

218
00:10:22,705 --> 00:10:25,580
ನಾವು ಹೋಗುತ್ತಿಲ್ಲ ಏಕೆಂದರೆ ಆದರೆ is--
ಪ್ರತಿ ಕಾರ್ಯ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಎಂದು

219
00:10:25,580 --> 00:10:28,610
ಸಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಗ್ರಂಥಾಲಯದ
ಆದರೆ, ನಿಮಗೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಆರ್

220
00:10:28,610 --> 00:10:32,110
ನೀವು ತೆಗೆದುಕೊಳ್ಳಲು ವಿಶೇಷವಾಗಿ ವೇಳೆ
reference.cs50.net ನೋಡಲು.

221
00:10:32,110 --> 00:10:35,000
ಮತ್ತು strcmp ನಿಜವಾಗಿಯೂ ಬಲಶಾಲಿ
ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಕಾರ್ಯ

222
00:10:35,000 --> 00:10:38,070
string.h ಹೆಡರ್
ಶೀರ್ಷಿಕೆ ಇದು ಕಡತ,

223
00:10:38,070 --> 00:10:41,970
ಕಾರ್ಯಗಳನ್ನು ಸಮರ್ಪಿಸಲಾಗಿದೆ ಎಂದು ಫೈಲ್
ಆ ಕೆಲಸ ಮತ್ತು ತಂತಿಗಳನ್ನು ಕುಶಲತೆಯಿಂದ.

224
00:10:41,970 --> 00:10:49,830
>> ವಿಶೇಷವಾಗಿ, ಏನು strcmp ಮಾಡುತ್ತದೆ
ಇದು ಎರಡು ತಂತಿಗಳು ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ.

225
00:10:49,830 --> 00:10:54,160
ಹಾಗಾಗಿ ತಪ್ಪು ವಿಭಜನೆ ಬಗ್ಗೆ ನಾನು
ಕರೆ ಕಾಣುತ್ತದೆ strcmp ಗೆ.

226
00:10:54,160 --> 00:10:58,530
ನಾನು ಹಿಟ್ N, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾನು ಸಂದೇಶವನ್ನು
ಪ್ರೋಗ್ರಾಂ ಸಿಗ್ನಲ್ SIGSEGV ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ

227
00:10:58,530 --> 00:11:01,370
ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ. ಈಗ
ನಾನು ವಾಸ್ತವವಾಗಿ seg faulted ಎಂದು,

228
00:11:01,370 --> 00:11:06,479
ಮತ್ತು ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಸಾಕಷ್ಟು ಹೊಂದಿದೆ
ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಿಟ್ಟುಬಿಟ್ಟಿದ್ದಾರೆ.

229
00:11:06,479 --> 00:11:07,770
ಈ ಪ್ರೋಗ್ರಾಂ ಅಂತ್ಯ.

230
00:11:07,770 --> 00:11:10,370
ಅದು ಮುರಿದು ಅದನ್ನು ಅಪ್ಪಳಿಸಿತು.

231
00:11:10,370 --> 00:11:14,740
ಆದ್ದರಿಂದ ಸಾಕಷ್ಟು ಅಲ್ಲ, ಆದರೆ ನಾನು
ವಾಸ್ತವವಾಗಿ ಸ್ವಲ್ಪ ಕಲಿತರು

232
00:11:14,740 --> 00:11:16,747
ಈ ಕಡಿಮೆ ಅನುಭವದಿಂದ.

233
00:11:16,747 --> 00:11:17,580
ನಾನು ಏನು ಕಲಿತಿರಿ?

234
00:11:17,580 --> 00:11:22,020
ಸರಿ, ನನ್ನ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ
ತಕ್ಷಣ ಬಹುಮಟ್ಟಿಗೆ.

235
00:11:22,020 --> 00:11:26,300
ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಭರಾಟೆ
ಒಂದು strcmp ಕರೆ, ಆದರೆ ನಾನು

236
00:11:26,300 --> 00:11:30,560
ಯಾವುದೇ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಇಲ್ಲ ನನ್ನ
ಇದು ಭರಾಟೆ ಆ ಸಮಯದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ.

237
00:11:30,560 --> 00:11:37,320
ಹಾಗಾಗಿ ಸ್ಟ್ರಿಂಗ್, ಅಥವಾ ತಂತಿಗಳು
ನಾನು ಬಹುಶಃ ಹೋಲಿಸುವ ಆಗಿರಬಹುದು.

238
00:11:37,320 --> 00:11:42,140
ನಾನು ಯಾವುದೇ ಸ್ಥಳೀಯ ಹೊಂದಿಲ್ಲದಿದ್ದರೆ
ಚರಾಂಕಗಳ ನೀವು ಮಾಡಬಹುದು

239
00:11:42,140 --> 00:11:45,520
ಬಹುಶಃ ನಾನು ಅಲ್ಲಿ ಹೊಂದಿಲ್ಲ ಎಂದು ಸಮ್ಮರೈಸ್
ನಿಜವಾದ ಸಾಧ್ಯವಿದೆ ಜಾಗತಿಕ ವೇರಿಯಬಲ್,.

240
00:11:45,520 --> 00:11:47,670
>> ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ತೋರುತ್ತದೆ
ಹಾಗೆ ನಾನು ಹೋಲಿಕೆ ಬಾಗುತ್ತೇನೆ

241
00:11:47,670 --> 00:11:52,070
ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಏನೋ.

242
00:11:52,070 --> 00:11:54,130
ಆದ್ದರಿಂದ ತನಿಖೆ ಅವಕಾಶ
ಸ್ವಲ್ಪ ಮುಂದೆ ಎಂದು.

243
00:11:54,130 --> 00:11:55,120
ಹಾಗಾಗಿ ನನ್ನ ಪರದೆಯ ತೆರವುಗೊಳಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

244
00:11:55,120 --> 00:11:57,536
ನಾನು ಹೊರಗೆ ಬಿಟ್ಟು ಪಡೆಯಲಿದ್ದೇನೆ
ಎರಡನೇ GDB ಪರಿಸರ.

245
00:11:57,536 --> 00:12:01,300
ನಾನು ಸರಿ, ನಾನು ಯೋಚಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ ಇಲ್ಲ
ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಯಾವುದೇ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು.

246
00:12:01,300 --> 00:12:06,444
ನಾನು ಪಾಸ್ ಆಗಿರಬೇಕು ಬಾಗುತ್ತೇನೆ ಬಹುಶಃ ನಾನು ಆಶ್ಚರ್ಯ
ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಚರ್ಚೆಯಂತೆ ಪಂಕ್ತಿಯಲ್ಲಿ.

247
00:12:06,444 --> 00:12:07,610
ಆದ್ದರಿಂದ ಈ ಔಟ್ ಪರೀಕ್ಷಿಸಲು ಅವಕಾಶ.

248
00:12:07,610 --> 00:12:09,020
ನಾನು ಮೊದಲು ಈ ಮಾಡದಿದ್ದರೆ.

249
00:12:09,020 --> 00:12:14,244
>> ಈ ಪ್ರೋಗ್ರಾಂ ಬಹುಶಃ ವೇಳೆ ನೋಡೋಣ
ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಚರ್ಚೆಯಂತೆ ಅದನ್ನು ಕೆಲಸ.

250
00:12:14,244 --> 00:12:16,140
ಶಬ್ದ, ಯಾವುದೇ ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ.

251
00:12:16,140 --> 00:12:17,870
ಇದು ಕೇವಲ ನಾನು ಅದನ್ನು ಕಾಣಿಸಿಕೊಂಡಿತ್ತು ಎಂದು ಹೇಳಿದ್ದರು.

252
00:12:17,870 --> 00:12:19,170
ಆದ್ದರಿಂದ ಬಹುಶಃ ಫಿಕ್ಸ್ ಇಲ್ಲಿ.

253
00:12:19,170 --> 00:12:27,560
ನಾನು ಮತ್ತೆ ಹೋಗಿ ವೇಳೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನೋಡಲು
buggy1.c ನಿಜವಾದ ಮೂಲ ಕೋಡ್,

254
00:12:27,560 --> 00:12:31,180
ನಾನು ಏನು ಆದರೂ ಇದು ತೋರುತ್ತದೆ
ನಾನು ಇಲ್ಲದೆ strcmp ಕರೆ ಮಾಡುವ ಬಾಗುತ್ತೇನೆ

255
00:12:31,180 --> 00:12:34,010
ವಾಸ್ತವವಾಗಿ argv [1] ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸುವ.

256
00:12:34,010 --> 00:12:36,730
ಈ ವಾಸ್ತವವಾಗಿ
buggy1.c ಮೂಲ ಕೋಡ್.

257
00:12:36,730 --> 00:12:38,855
ಆದ್ದರಿಂದ ನಾನು ಅಗತ್ಯವಿರುವ
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಸರಿಪಡಿಸಲು ಇಲ್ಲಿ,

258
00:12:38,855 --> 00:12:40,835
ಊಹಿಸಿಕೊಂಡು ನಾನು
, ನನಗೆ ಮುಂದೆ ಫೈಲ್

259
00:12:40,835 --> 00:12:44,740
ಕೇವಲ ಮಾಡಲು ಒಂದು ಚೆಕ್ ಸೇರಿಸಲು
ಖಚಿತವಾಗಿ ಆ argc 2 ಸಮಾನವಾಗಿರುತ್ತದೆ.

260
00:12:44,740 --> 00:12:47,780
ಆದ್ದರಿಂದ ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಮತ್ತೆ ನಾನು, ಹೇಳಿದ ಹಾಗೆ
ಬಲ, ಸ್ವಲ್ಪ contrived ಇದು?

261
00:12:47,780 --> 00:12:49,840
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಹೋಗುತ್ತಿಲ್ಲ
ಆಕಸ್ಮಿಕವಾಗಿ ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಅಳಿಸಬಹುದು

262
00:12:49,840 --> 00:12:51,820
ತದನಂತರ ಪ್ರಯತ್ನಿಸಬೇಕು
ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ದೋಷ.

263
00:12:51,820 --> 00:12:53,120
ಆದರೆ ಆಶಾದಾಯಕವಾಗಿ, ಕೊಡುತ್ತಾನೆ
ನೀವು ಸಚಿತ್ರ

264
00:12:53,120 --> 00:12:55,120
ವಸ್ತುಗಳ ರೀತಿಯ ಆ
ನೀವು ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಬಹುದು

265
00:12:55,120 --> 00:12:56,610
ನೀವು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಡೀಬಗ್ ನೀವು.

266
00:12:56,610 --> 00:12:58,760
>> ಇಲ್ಲಿ ವ್ಯವಹಾರಗಳ ರಾಜ್ಯ ಯಾವುದು?

267
00:12:58,760 --> 00:13:00,510
ಏನು ವ್ಯತ್ಯಾಸಗಳ ನಾನು
ನನಗೆ ಸುಲಭವಾಗಿ ಹೊಂದಿವೆ?

268
00:13:00,510 --> 00:13:03,600
ಅಲ್ಲಿ ನಿಖರವಾಗಿ ನನ್ನ ಕಾರ್ಯಕ್ರಮ
ಯಾವ ಸಾಲು ಕ್ರ್ಯಾಶಿಂಗ್,

269
00:13:03,600 --> 00:13:05,240
ಯಾವ ಕಾರ್ಯವನ್ನು ಮಾಡಬೇಕೆಂದು ಕರೆ?

270
00:13:05,240 --> 00:13:06,952
ಸುಳಿವುಗಳನ್ನು ಯಾವ ರೀತಿಯ ನನಗೆ ನೀಡಿದ್ದರು?

271
00:13:06,952 --> 00:13:08,910
ಮತ್ತು ನಿಖರವಾಗಿ
ಮನಸ್ಸು ರೀತಿಯ ನೀವು

272
00:13:08,910 --> 00:13:12,820
ನೀವು ಇರುವಾಗ ಬರುವುದು ಮಾಡಬೇಕು
ನಿಮ್ಮ ಡೀಬಗ್ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ವಿಚಾರ.

273
00:13:12,820 --> 00:13:13,820
>> ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.

274
00:13:13,820 --> 00:13:16,140
ಈ CS50 ಹೊಂದಿದೆ.

275
00:13:16,140 --> 00:15:08,642