1
00:00:07,170 --> 00:00:12,630
[Powered by Google Translate] GDB, GNU ಪ್ರಾಜೆಕ್ಟ್ ಡೀಬಗರ್, ಸಿ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಡೀಬಗ್ ಸಾಧನವಾಗಿದೆ

2
00:00:12,630 --> 00:00:14,300
ಇತರ ಭಾಷೆಗಳ ಜೊತೆಗೆ.

3
00:00:14,300 --> 00:00:17,440
ಅವರು ಪಾಲಿಸಲು ಮಾಡುತ್ತಲೇ ನೀವು, ನಿಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಮ್ಗಳ ಒಳಗಡೆ ಸುಮಾರು ಇರಿ ಅನುಮತಿಸುತ್ತದೆ

4
00:00:17,440 --> 00:00:20,880
ಮತ್ತು ಇದು ನೀವು ಸಂಭವಿಸುತ್ತದೆ ನಿಖರವಾಗಿ ಏನನ್ನು ನೋಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ

5
00:00:20,880 --> 00:00:22,490
ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ.

6
00:00:22,490 --> 00:00:24,690
ಅದು ಸರಿ, ಬಹಳ ನಿಫ್ಟಿ ಈಸ್?

7
00:00:24,690 --> 00:00:27,980
GDB ಉಚಿತ ಸಾಫ್ಟ್ವೇರ್ ಆಗಿದೆ, ಮತ್ತು ಇದು ಹಲವು ಜನಪ್ರಿಯ Unix ಚಲಿಸುತ್ತದೆ ಮತ್ತು

8
00:00:27,980 --> 00:00:31,840
ವಿಂಡೋಸ್ ಆಧಾರಿತ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳು, ಆದ್ದರಿಂದ ಬಹಳ ವ್ಯಾಪಕ ಪರಿಕರವಾಗಿದ್ದು.

9
00:00:31,840 --> 00:00:33,560
>> ನೀವು ಪ್ರೀತಿಸುವ ಕಲಿತುಕೊಳ್ಳಬೇಕು.

10
00:00:33,560 --> 00:00:36,800
GDB ಸಾಧಕ ದೋಷಗಳನ್ನು ಕೆಳಗೆ ಟ್ರ್ಯಾಕ್ ಒಂದು ತುಂಬಾ ಸುಲಭವಾಗುತ್ತದೆ

11
00:00:36,800 --> 00:00:39,150
ಊಹೆಗಳು ಬಳಸುವ ಮೂಲಕ ಅವ್ಯವಸ್ಥೆ ಯಾರು ಹೆಚ್ಚು

12
00:00:39,150 --> 00:00:41,420
ಮತ್ತು ಪ್ರಿಂಟ್ ಔಟ್ ಹೇಳಿಕೆಗಳ ಅನಂತ ಪ್ರಮಾಣದಲ್ಲಿ.

13
00:00:41,420 --> 00:00:45,810
GDB ನೀವು ಟರ್ಮಿನಲ್ ಅದನ್ನು ಸಂವಾದಿಸಬಹುದು ಅಂದರೆ, ಒಂದು ಆಜ್ಞಾ ಸಾಲು ಉಪಕರಣವಾಗಿರುತ್ತದೆ

14
00:00:45,810 --> 00:00:49,720
ನಿಮ್ಮ ಇಲಿಯನ್ನು ಕೀಬೋರ್ಡ್ ಮೂಲಕ ಆದೇಶಗಳ ಬದಲಿಗೆ ಕ್ಲಿಕ್ ಬಟನ್ ನೀಡುವ.

15
00:00:49,720 --> 00:00:54,960
>> GDB ಅನ್ನು ಆರಂಭಿಸಲು, ನೀವು ಅಕ್ಷರಶಃ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ಹಿಟ್ ಕೇವಲ ರೀತಿಯ GDB ನಮೂದಿಸಿ.

16
00:00:54,960 --> 00:00:58,230
ನೀವು ತೆರೆಗೆ ಔಟ್ ಮುದ್ರಿತ ಕೆಲವು ಸಾಲುಗಳನ್ನು ನೋಡುತ್ತಾರೆ

17
00:00:58,230 --> 00:01:00,810
, ನೀವು ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ ಎಂದು ನೀವು GDB ಆವೃತ್ತಿಯನ್ನು ತೋರಿಸುವ

18
00:01:00,810 --> 00:01:07,890
ಕಾಪಿರೈಟ್ ಮಾಹಿತಿ, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ನೀವು GDB ಪ್ರಾಂಪ್ಟ್ ನೋಡುತ್ತಾರೆ: (GDB).

19
00:01:07,890 --> 00:01:10,770
ನೀವು GDB ಆಜ್ಞೆಗಳನ್ನು ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

20
00:01:10,770 --> 00:01:15,400
ಈ ಹಂತದಲ್ಲಿ, ಹೇಗೆ ತಿಳಿಯಲು ಪ್ರಮುಖ ವಿಷಯ ಬಿಟ್ಟು ಇದೆ.

21
00:01:15,400 --> 00:01:17,790
ಅದೃಷ್ಟವಶಾತ್, ಇದು ತುಂಬಾ ಸುಲಭ.

22
00:01:17,790 --> 00:01:19,840
ಬಿಟ್ಟು ಆಜ್ಞೆಯನ್ನು ಕೇವಲ ಮಾಡುತ್ತದೆ.

23
00:01:19,840 --> 00:01:23,090
ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಮಾಹಿತಿ, ನೀವು ಪ್ರಶ್ನೆ ತುಂಬಾ ಬಳಸಬಹುದು.

24
00:01:23,090 --> 00:01:27,410
ಮೋಜಿನ GDB ಅನ್ನು ಬೂಟ್ ತದನಂತರ ಕೂಡಲೇ ತೊರೆದು ಎಂದು ಆಗಿದೆ,

25
00:01:27,410 --> 00:01:30,800
ಒಂದು ಪ್ರೋಗ್ರಾಂ ದೋಷ ಸಹಾಯ GDB ಬಳಸಿಕೊಂಡು ಬಗ್ಗೆ ಈಗ ನೋಡೋಣ.

26
00:01:30,800 --> 00:01:34,630
>> ಆರಂಭಿಸಲು, ನಾನು ಇಲ್ಲಿ factorial.c ಒಂದು ಪ್ರೋಗ್ರಾಂ ಪಡೆದಿರುವಿರಿ

27
00:01:34,630 --> 00:01:37,380
ಒಂದು ಇಂಟ್ ಪಡೆಯುತ್ತದೆ ಮತ್ತು ತನ್ನ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಾಚಾರ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

28
00:01:37,380 --> 00:01:41,270
ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಮೊದಲು factorials ನೋಡಿಯೇ ಇಲ್ಲ ಅಥವಾ ಅವುಗಳನ್ನು ನೆನಪಿರುವುದಿಲ್ಲ

29
00:01:41,270 --> 00:01:47,840
ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ N N ಗುಣಲಬ್ಧಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ - (n - 1), (n - 2), ಹೀಗೆ -

30
00:01:47,840 --> 00:01:49,230
ನೀವು 1 ಹಿಟ್ ರವರೆಗೆ.

31
00:01:49,230 --> 00:01:54,550
ಆದ್ದರಿಂದ, 3 ಅಪವರ್ತನೀಯ 3 * 2 * 1, ಅಥವಾ 6,

32
00:01:54,550 --> 00:02:00,180
ಮತ್ತು 4 ಅಪವರ್ತನೀಯ 4 * 3 * 2 * 1, ಅಥವಾ 24.

33
00:02:00,180 --> 00:02:03,970
ಶೂನ್ಯ ಅಪವರ್ತನೀಯ ಬೆಸ ಸಂದರ್ಭದಲ್ಲಿ, ಇದನ್ನು, 1 ನ

34
00:02:03,970 --> 00:02:06,970
ಮತ್ತು ಋಣ ಪೂರ್ಣಾಂಕಗಳ factorials ನಿರೂಪನೆಯಾಗಿಲ್ಲ.

35
00:02:06,970 --> 00:02:10,280
ಹೇಗಾದರೂ, ನನ್ನ ಅಪವರ್ತನೀಯ ಕಾರ್ಯಕ್ರಮದ ಬಗ್ಗೆ ಏನಾದರೂ ಮೋಜಿನ ಹೊಂದಿದೆ.

36
00:02:10,280 --> 00:02:15,410
ನಾನು ಔಟ್ ಅದು factorials ಏನೂ ಹೊಂದಿರುವ ವಿಲಕ್ಷಣ ಸಂಖ್ಯೆಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

37
00:02:15,410 --> 00:02:19,030
>> ಆದ್ದರಿಂದ, ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಸಹಾಯ GDB ಬಳಸಬಹುದು.

38
00:02:19,030 --> 00:02:21,720
GDB, ಕಾರ್ಯಸಾಧ್ಯವಾದ ಕಡತಗಳನ್ನೂ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

39
00:02:21,720 --> 00:02:24,910
ಇದು ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ಮಾಣದ ಬೈನರಿ ಕಡತಗಳನ್ನು.

40
00:02:24,910 --> 00:02:30,940
ಅಂದರೆ, ನಮ್ಮ. ಸಿ ಮೇಲೆ GDB ರನ್ ಅಥವಾ ಸಾಧ್ಯವಿಲ್ಲ. Factorial.c ನಂತಹ H ಮೂಲ ಕೋಡ್ ಕಡತಗಳು.

41
00:02:30,940 --> 00:02:34,650
ನಾವು ಕೇವಲ ಅಪವರ್ತನೀಯ ಟಾಪಿನಲ್ಲಿ ಚಲಾಯಿಸಲು ಬಯಸುವ.

42
00:02:34,650 --> 00:02:38,340
ಪ್ರೋಗ್ರಾಂ ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಅಗತ್ಯವಿದ್ದಲ್ಲಿ,

43
00:02:38,340 --> 00:02:40,230
ನಾವು ಅವುಗಳನ್ನು ಸೂಚಿಸಿ ಬಯಸುವ ಇದು.

44
00:02:40,230 --> 00:02:44,050
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅಪವರ್ತನೀಯ, ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ

45
00:02:44,050 --> 00:02:46,410
ಆದ್ದರಿಂದ ನಾವು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ರನ್ ಅಥವಾ R ಟೈಪಿಸಿ.

46
00:02:46,410 --> 00:02:50,440
>> ಈ ಅಪವರ್ತನೀಯ ಪ್ರೋಗ್ರಾಂ ಓಟ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

47
00:02:50,440 --> 00:02:53,940
ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ನಿಂತಾಗ, ನನ್ನ GDB ಮತ್ತೆ ಕೇಳುತ್ತದೆ ಪಡೆಯುತ್ತೀರಿ.

48
00:02:53,940 --> 00:02:58,130
ಸರಿ, ನ 4 ಅಪವರ್ತನೀಯ, ಮತ್ತೆ ಒಂದೇ ಪ್ರಯತ್ನಿಸೋಣ.

49
00:02:58,130 --> 00:03:02,910
ಸರಿ, ನಾವು GDB ಇಲ್ಲಿ ಜಂಕ್ ಅದೇ ರೀತಿಯ ಪಡೆಯುತ್ತಿದ್ದೀರಿ ಎಂದು ನೋಡಿ.

50
00:03:02,910 --> 00:03:04,850
ಪ್ರೋಗ್ರಾಂ ಮುಗಿದಿದೆ ಈಗ ಆ,

51
00:03:04,850 --> 00:03:06,870
ನಾವು ಹೋಗಿ ತನ್ನ ರಾಜ್ಯದ ಯಾವುದೇ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

52
00:03:06,870 --> 00:03:09,870
ಆದ್ದರಿಂದ ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಮೊದಲು ಮತ್ತೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಆರಂಭಿಸಲು ಅಗತ್ಯವಿದೆ.

53
00:03:09,870 --> 00:03:13,570
ಆದರೆ, ನಾವು ಅದರ ರನ್ ಮಧ್ಯದಲ್ಲಿ ವಿಷಯವೆಂದರೆ ಅದನ್ನು ನಿಲ್ಲಿಸಲು ಒಂದು ದಾರಿ ಬೇಕಿದೆ.

54
00:03:13,570 --> 00:03:16,970
>> ಹಾಗೆ ಮಾಡಲು, ನಾವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಎಂದು ಏನನ್ನು ಬಳಸಿ.

55
00:03:16,970 --> 00:03:21,880
ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಅಥವಾ ಮೂಲ ಕೋಡ್ ಸಾಲಿನಲ್ಲಿ ವಿರಾಮ ಪ್ರೋಗ್ರಾಂಗೆ GDB ತಿಳಿಸಿ

56
00:03:21,880 --> 00:03:24,070
ಆದ್ದರಿಂದ ನಾವು, ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಪರೀಕ್ಷಿಸಲು ಮಾಡಬಹುದು

57
00:03:24,070 --> 00:03:27,380
ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳು, ಮೆಮೊರಿ ರಾಜ್ಯ ಮತ್ತು, ಆ ಸಮಯದಲ್ಲಿ.

58
00:03:27,380 --> 00:03:30,750
ನಾನು ವಿಷಯಗಳನ್ನು ತಪ್ಪು ಹೋಗುವ ಅಲ್ಲಿ ಗೊತ್ತಿಲ್ಲ ಏಕೆಂದರೆ,

59
00:03:30,750 --> 00:03:33,510
>> ನಾನು, ಬಲ ಬಹಳ ಆರಂಭದಲ್ಲಿ ಡೀಬಗ್ ಆರಂಭಿಸಲು ಬಯಸುವ

60
00:03:33,510 --> 00:03:36,510
ಮುಖ್ಯ ಆರಂಭವಾಗುತ್ತದೆ ಬಲ ಮಾಡಿದಾಗ.

61
00:03:36,510 --> 00:03:39,260
ನಾವು ವಿರಾಮ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮುಖ್ಯ ಆರಂಭದಲ್ಲಿ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಮಾಡುತ್ತೇವೆ.

62
00:03:39,260 --> 00:03:42,640
ನಾವು ವಿರಾಮ ಮೊಟಕಾದ ಗೆ ಬೌ ಬಳಸಬಹುದು.

63
00:03:42,640 --> 00:03:45,000
ಈಗ ಕಾರ್ಯಕ್ರಮ ಮತ್ತೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಆರಂಭಿಸೋಣ.

64
00:03:45,000 --> 00:03:48,140
ಇಲ್ಲಿ ನಾವು GDB ತಿಳಿಸುತ್ತದೆ ಕೇವಲ ನಂತಹ ಪ್ರಮುಖ ಆರಂಭದಲ್ಲಿ ಅವು.

65
00:03:48,140 --> 00:03:51,970
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಗ್ಗೆ ಆದರೆ ಇನ್ನೂ ಆ ಕೋಡ್ ಸಾಲು

66
00:03:51,970 --> 00:03:53,480
printf ರೇಖೆ.

67
00:03:53,480 --> 00:03:57,200
ನಾವು ಕೋಡ್ ಈ ಸಾಲಿನ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು GDB ಹೇಳಬಹುದು

68
00:03:57,200 --> 00:03:59,840
ಮುಂದಿನ ಅಥವಾ N ಆಜ್ಞೆ.

69
00:03:59,840 --> 00:04:04,120
>> ಸರಿ, ಈಗ GDB ನಾವು GetInt ಸಾಲಿನಲ್ಲಿ ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತದೆ.

70
00:04:04,120 --> 00:04:06,630
ನಾನು printf ಲೈನ್ ಔಟ್ ಇಲ್ಲ ತೋರುತ್ತಿದೆ ತಿಳಿದಿದೆ

71
00:04:06,630 --> 00:04:10,070
ನಾವು ಕಾಣುವುದಿಲ್ಲ ನಂತರ, ಪರದೆಯ ಮೇಲೆ ಪ್ರಿಂಟ್ ಔಟ್ "ಒಂದು ಧನಾತ್ಮಕ ಪೂರ್ಣಸಂಖ್ಯೆ ನಮೂದಿಸಿ"

72
00:04:10,070 --> 00:04:12,040
ಆದರೆ ಇದು ವಾಸ್ತವವಾಗಿ ಔಟ್ ನೀಡಲಿಲ್ಲ.

73
00:04:12,040 --> 00:04:16,029
ನಾವು ನೋಡಿದ ನೀವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ತೆರೆಗೆ ಬರವಣಿಗೆ ಏನು ದಮನ ಆಗಿದೆ

74
00:04:16,029 --> 00:04:19,649
ಸಂಪೂರ್ಣವಾಗಿ ಏಕೆ ಮುದ್ರಿತಪ್ರತಿಗಳನ್ನು ಜೊತೆ ಡೀಬಗ್ ಇದು ಬರುತ್ತದೆ ರವರೆಗೆ

75
00:04:19,649 --> 00:04:21,730
ಕೆಲವೊಮ್ಮೆ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ ಕಾಣಿಸಬಹುದು.

76
00:04:21,730 --> 00:04:26,240
ಹೇಗಾದರೂ, ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಿ ಒಂದು ಇಂಟ್ ನಲ್ಲಿ ನಮೂದಿಸಿ ಮತ್ತೆ ನೋಡೋಣ.

77
00:04:26,240 --> 00:04:30,070
ಮತ್ತೆ, ಕೌಟುಂಬಿಕತೆ 4 ನೋಡೋಣ.

78
00:04:30,070 --> 00:04:34,540
ಆದ್ದರಿಂದ ಈ ವಿಲಕ್ಷಣ ಕಾಣುತ್ತದೆ. ನಾವು, GDB ಪ್ರಕಾರ ಸಾಲಿನ 12 ರಂದು ಆರ್

79
00:04:34,540 --> 00:04:37,660
ಆದರೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಗ್ಗೆ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ಕೇವಲ ಕರ್ಲಿ ಕಟ್ಟುಪಟ್ಟಿಯು.

80
00:04:37,660 --> 00:04:42,110
>> ನಾವು ಒಂದು ಲೂಪ್ ಕೊನೆಯಲ್ಲಿ ನಾವು ಅಂದರೆ, ನಮ್ಮ ಹಾಗೆ ಆದರೆ ವಾಸ್ತವವಾಗಿ ಲೂಪ್,

81
00:04:42,110 --> 00:04:46,710
ಮತ್ತು GDB ನಮಗೆ ಹೇಳುವುದು ಮುಕ್ತಾಯ ನಿಯಮ, ಶೂನ್ಯ ಹೆಚ್ಚು ಅಂದರೆ ಯಾವುದೇ ಕಡಿಮೆ,

82
00:04:46,710 --> 00:04:48,010
ಮುಂದಿನ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

83
00:04:48,010 --> 00:04:50,230
ಈ ಹಿಂದೆಂದೂ ಸ್ವಲ್ಪ ಗೊಂದಲಕ್ಕೆ ಗೆಟ್ಸ್ ವೇಳೆ,

84
00:04:50,230 --> 00:04:54,860
ನಾವು ಪಟ್ಟಿ ಅಥವಾ L ಆಜ್ಞೆಯನ್ನು GDB ಸೋರ್ಸ್ ಕೋಡ್ ಅಪ್ ಬರಬಹುದು.

85
00:04:54,860 --> 00:04:56,880
ಈ ಮೂಲ ಕೋಡ್ ಔಟ್ ತೋರಿಸುತ್ತದೆ

86
00:04:56,880 --> 00:04:59,010
ನಾವು ಪ್ರಸ್ತುತ ನೀವು ಆ ಸಾಲಿನಲ್ಲಿ ಸುತ್ತ ನ.

87
00:04:59,010 --> 00:05:03,590
ನಾವು ಮತ್ತೆ ಪಟ್ಟಿ ಅಥವಾ L ಟೈಪ್ ವೇಳೆ, ನಾವು ರೇಖೆಗಳ ಮುಂದಿನ ಸೆಟ್ ಮುದ್ರಿಸುತ್ತದೆ ನೋಡುತ್ತಾರೆ.

88
00:05:03,590 --> 00:05:06,070
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ತನಕ ನಾವು ಮಾಡಬಹುದು.

89
00:05:06,070 --> 00:05:11,210
>> ನಾವು ಅಲ್ಲಿ ಮರಳಿ ಪಡೆಯಲು, ನಾವು, ಒಂದು ಸಾಲಿನ ಸಂಖ್ಯೆಯ ಪಟ್ಟಿ ಪೂರೈಸುವ

90
00:05:11,210 --> 00:05:14,120
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಾಲು 12.

91
00:05:14,120 --> 00:05:16,040
ಹೇಗಾದರೂ, ಅವರ ಮೇಲೆ ಚಲಿಸೋಣ.

92
00:05:16,040 --> 00:05:18,240
ಈಗ ನಾವು 4 ಲೂಪ್ ಇದ್ದೇವೆ.

93
00:05:18,240 --> 00:05:21,490
ಲೆಟ್ಸ್ ನಮ್ಮ NUM ವೇರಿಯಬಲ್ 4 ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

94
00:05:21,490 --> 00:05:26,170
ನಾವು ಮುದ್ರಣ, ಅಥವಾ ಪು, ಆಜ್ಞೆಯನ್ನು ನೀವು ಹಾಗೆ.

95
00:05:26,170 --> 00:05:31,140
ಆದ್ದರಿಂದ, GDB ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ NUM ವಾಸ್ತವವಾಗಿ, 4 ಸಂಗ್ರಹಿಸಲು ಎಂದು ನಮಗೆ ಹೇಳುತ್ತದೆ.

96
00:05:31,140 --> 00:05:35,180
ಆ GDB ಮುದ್ರಿಸುತ್ತದೆ $ 1 ಔಟ್ ವಿಶೇಷ GDB ವ್ಯತ್ಯಯ

97
00:05:35,180 --> 00:05:37,720
ಈಗ ಜೊತೆಗೆ ಸಂಖ್ಯೆ 4 ಶೇಖರಿಸಿಡಲು ಹೊಂದಿಸಲಾಗಿದೆ.

98
00:05:37,720 --> 00:05:42,240
ನೀವು ಈಗ ಈ ಅಲಕ್ಷಿಸಬಹುದು, ಆದರೆ ಈ GDB ಅಸ್ಥಿರ HANDY ಸೂಪರ್ ಬರುತ್ತವೆ

99
00:05:42,240 --> 00:05:46,380
ಹೆಚ್ಚು ಮುಂದುವರಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು ಹಿಂದೆ ಮಾಡಿದ ಯಾವ ಮರುಪಡೆಯಲು ಬಯಸಿದಾಗ.

100
00:05:46,380 --> 00:05:50,970
ಹೇಗಾದರೂ, ಮುಂದಿನ ನಲ್ಲಿ ಚಲಿಸುವ, ನಾವು ಲೂಪ್ ಫಾರ್ ಮೂಲಕ ತೆರಳುತ್ತಾರೆ ಎಂದು ನೋಡಿ.

101
00:05:50,970 --> 00:05:54,790
ಬಿಟ್ ಮೂಲಕ N ಬಿಟ್ ಇಲ್ಲಿ ಮೂಲಕ ಮುಂದುವರಿಸುವುದಕ್ಕೆ ನೋಡೋಣ.

102
00:05:54,790 --> 00:05:58,280
ಬದಲಿಗೆ ಟೈಪಿಂಗ್ N ಪ್ರತಿ ಬಾರಿ ಹೆಚ್ಚು, ನೀವು ನಮೂದಿಸಿ ಹೊಡೆಯಬಹುದು ಕೇವಲ.

103
00:05:58,280 --> 00:06:03,710
ನೀವು ಏನು ಟೈಪ್ ಇಲ್ಲದೆ ನಮೂದಿಸಿ ಹೊಡೆದಾಗ, GDB ಕೇವಲ ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಪುನರಾವರ್ತನೆಯಾಗಿದೆ.

104
00:06:03,710 --> 00:06:05,910
ಈಗ ನಾವು printf ಕರೆ ಹಿಟ್ ಮಾಡಿದ.

105
00:06:05,910 --> 00:06:09,520
ನಾವು ನಿಜಕ್ಕೂ ಲೂಪ್ 4 ಬಾರಿ ನಮ್ಮ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ ಎಂದು, ಹುಡುಕುತ್ತದೆ

106
00:06:09,520 --> 00:06:13,750
ಇದು ನಾವು 1, 2, 3, ಮತ್ತು 4 ರಿಂದ ಗುಣಿಸುವುದು ಸಲುವಾಗಿ ಮಾಡಲು ಯಾವ ಹೊಂದಿದೆ.

107
00:06:13,750 --> 00:06:15,870
>> ಎಲ್ಲವೂ ಕೆಲಸ ರೀತಿಯಲ್ಲಿಯೇ ತೋರುತ್ತದೆ,

108
00:06:15,870 --> 00:06:19,680
ನಾವು ಮುಂದಿನ ಮತ್ತೆ ಹೊಡೆದಾಗ ಹೊರತುಪಡಿಸಿ ನಾವು ಬದಲಿಗೆ 24 ಈ ಭಾರಿ ಸಂಖ್ಯೆ ಸಿಗುತ್ತದೆ.

109
00:06:19,680 --> 00:06:23,100
ನಾವು ಅಪವರ್ತನೀಯ ಬಳಸಿಕೊಂಡು ಪುಟ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ವೇಳೆ,

110
00:06:23,100 --> 00:06:26,120
ನಾವು ಅಪವರ್ತನೀಯ ಇದು ಈ ಭಾರಿ ಸಂಖ್ಯೆಯ ಎಂಬುದನ್ನು ನೋಡಿ.

111
00:06:26,120 --> 00:06:28,740
ಯಾವುದೋ ಖಂಡಿತವಾಗಿಯೂ ತಪ್ಪು ವಿಶೇಷವೇನು.

112
00:06:28,740 --> 00:06:31,960
ಈ ಹಂತದಲ್ಲಿ, ಆದರೂ, ನಾವು, ಸುಮಾರು ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿದೆ

113
00:06:31,960 --> 00:06:34,610
ಮತ್ತು ಅದು ಏನು ಸರಿಪಡಿಸಲು ತಡವಾಗಿ ಇಲ್ಲಿದೆ.

114
00:06:34,610 --> 00:06:39,750
>> ಆದರೆ, ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತೆ ತದನಂತರ ವೈ ಆರ್ ನಮೂದಿಸುವ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭಿಸುತ್ತವೆ.

115
00:06:39,750 --> 00:06:43,460
ಈಗ ನಾವು ಮುಖ್ಯ ಆರಂಭದಲ್ಲಿ ನಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಂದೆ ಆರ್.

116
00:06:43,460 --> 00:06:46,600
ನಾವು ಎಲ್ಲವನ್ನೂ N ರಲ್ಲಿ ಓದುವ ಉತ್ತಮ ತೋರುತ್ತದೆ ತಿಳಿದಿದೆ.

117
00:06:46,600 --> 00:06:48,630
ಆದ್ದರಿಂದ ನಾವು, n ಮುಂದೆ ದಾಟಬಲ್ಲಿರಿ.

118
00:06:48,630 --> 00:06:52,280
ಏನು ನಂತರ ಪರ್ಯಾಯವಾಗಿ, ನಾವು ಒಂದು ಹೊಸ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಮಾಡುತ್ತದೆ ಲೂಪ್

119
00:06:52,280 --> 00:06:54,910
ಹಾಗೂ ಜಿಗಿತವನ್ನು. ನ ಹಾಗೆ ಬಿಡಿ.

120
00:06:54,910 --> 00:06:59,080
ಸಾಲು 14 ಕೇವಲ ಲೂಪ್ ನಂತರ ಬರುತ್ತದೆ ತೋರುತ್ತಿದೆ.

121
00:06:59,080 --> 00:07:01,070
ನ ಇಲ್ಲಿ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಅವಕಾಶ.

122
00:07:01,070 --> 00:07:05,220
ಈ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಆಜ್ಞೆಯಲ್ಲಿ ಫೈಲ್ ಹೆಸರನ್ನು ಸೂಚಿಸಲು ಉತ್ತಮ ಇಲ್ಲಿದೆ

123
00:07:05,220 --> 00:07:08,480
ನೀವು ಬಹು ಫೈಲ್ಗಳನ್ನು ಕೆಲಸ ಬಳಸುತ್ತಿದ್ದರೆ GDB ತಪ್ಪಾಗಿ ಏಕೆಂದರೆ.

124
00:07:08,480 --> 00:07:13,230
ಮುಂದೆ ಈ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ನ ಸರಿಸಲು, ನಾವು ಮುಂದುವರಿಸಲು ಅಥವಾ ಸಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

125
00:07:13,230 --> 00:07:16,570
>> ಸರಿ, ಇಲ್ಲಿ ನಾವು ಲೂಪ್ ಕಾಲ ಇರುತ್ತದೆ.

126
00:07:16,570 --> 00:07:19,060
ನ ಲೂಪ್ ಫಾರ್ ಒಳಗೆ 1 ಹೆಚ್ಚು ಲೈನ್ ಹೋಗಿ ಅವಕಾಶ

127
00:07:19,060 --> 00:07:21,630
ನಂತರ ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಮುದ್ರಣ ಅಸ್ಥಿರ ಪ್ರಾರಂಭಿಸಿ.

128
00:07:21,630 --> 00:07:26,410
ಲೆಟ್ಸ್ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ನಾನು, ವಾಸ್ತವವಾಗಿ 1 ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

129
00:07:26,410 --> 00:07:28,300
ಎಲ್ಲಾ ಉತ್ತಮ ಎಂದು ಹೌದು.

130
00:07:28,300 --> 00:07:30,270
ಅಪವರ್ತನೀಯ ಬಗ್ಗೆ ಏನು ಹೇಳಬಹುದು?

131
00:07:30,270 --> 00:07:33,760
ಯಾವುದೇ ಉತ್ತಮ ಎಂದು ಓಹ್,.

132
00:07:33,760 --> 00:07:35,800
ನಾವು ಇಲ್ಲಿ ಒಂದು ದೊಡ್ಡ ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ ಮಾಡಲೇಬೇಕು.

133
00:07:35,800 --> 00:07:38,190
ಉಂಟಾಗುವ How'd?

134
00:07:38,190 --> 00:07:40,040
ಹಾಗೆಯೇ, ನಾವು ಕೋಡ್ ಹಿಂತಿರುಗಿ ನೋಡಲು ವೇಳೆ,

135
00:07:40,040 --> 00:07:44,800
ನಾವು ಅದನ್ನು ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಇಲ್ಲ ನೋಡಿ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಕಸದ ಮಾಡಲೇಬೇಕು.

136
00:07:44,800 --> 00:07:46,820
ಅದು ಖಂಡಿತ ನಮ್ಮ ಲೆಕ್ಕ ದೂರ ಕಾಣಿಸುತ್ತದೆ.

137
00:07:46,820 --> 00:07:49,930
>> ಅದೃಷ್ಟವಶಾತ್, ಈ ಸರಿಪಡಿಸಲು GDB ಬಿಡಲು ಇಲ್ಲ.

138
00:07:49,930 --> 00:07:54,590
ನಾವು ಇಲ್ಲಿ ಆರಂಭಿಸಲು ಮತ್ತು ನಂತರ print ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಕೋಡ್ ಇದನ್ನು ಹೊಂದಿಸಬಹುದು.

139
00:07:54,590 --> 00:07:59,500
ಶೂನ್ಯ ಮತ್ತು 1 factorials 1 ಎರಡೂ ಕಾರಣ ನಾವು, 1 ಇದನ್ನು ಆರಂಭಿಸಲು ಮಾಡುತ್ತೇವೆ

140
00:07:59,500 --> 00:08:03,940
ನಾವು ಶೂನ್ಯ ಅದನ್ನು ಆರಂಭಿಸಲು ವೇಳೆ ಮತ್ತು ನಂತರ ನಾವು ಯಾವಾಗಲೂ ನಮ್ಮ ಪರಿಣಾಮವಾಗಿ ಶೂನ್ಯ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಬಯಸುವ.

141
00:08:03,940 --> 00:08:08,370
ನೀವು ಸೂಪರ್ HANDY ಇದು ಯಾವುದೇ ವೇರಿಯಬಲ್ ಈ ರೀತಿಯಲ್ಲಿ, ಹೊಂದಿಸಬಹುದು.

142
00:08:08,370 --> 00:08:10,920
ಈಗ, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ಮುಂದುವರಿಸಲು ಅವಕಾಶ.

143
00:08:10,920 --> 00:08:14,040
ಲೆಟ್ಸ್ ಇದು ಮಾಡಬೇಕೋ ಅಲ್ಲಿ ಎಲ್ಲವೂ ಇಲ್ಲಿದೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

144
00:08:14,040 --> 00:08:19,090
ಸಂ 4, ನಾನು 1 ಆಗಿರಬೇಕು, ಮತ್ತು ಅಪವರ್ತನೀಯ ತುಂಬಾ 1 ಆಗಿರಬೇಕು.

145
00:08:19,090 --> 00:08:23,990
ನಾವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಶಾರ್ಟ್ಕಟ್ ಮತ್ತು ನಮ್ಮ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಎಲ್ಲಾ ಮುದ್ರಿಸಬಹುದು

146
00:08:23,990 --> 00:08:26,440
ಸೂಪರ್ ಸಹಾಯಕವಾಗಿದೆಯೆ ಆಜ್ಞೆಯನ್ನು ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರಲ್ಲಿ,

147
00:08:26,440 --> 00:08:29,190
ಇದು ನಮ್ಮ ಇನ್ ಸ್ಕೋಪ್ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಎಲ್ಲಾ ಮುದ್ರಿಸುತ್ತದೆ.

148
00:08:29,190 --> 00:08:31,980
ಎಲ್ಲವನ್ನೂ ಹೋಗಲು ಒಳ್ಳೆಯದು ನಂತಹ ಹೇಗಾದರೂ, ಇದು ಕಾಣುತ್ತದೆ.

149
00:08:31,980 --> 00:08:34,700
>> ಕೇವಲ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತೊಂದು GO-ಸುತ್ತ ಕುಣಿಕೆ ಮಾಡೋಣ ನ.

150
00:08:34,700 --> 00:08:38,789
ಸರಿ, ಎಲ್ಲವನ್ನೂ ಮಹಾನ್ ಕಾಣುತ್ತದೆ.

151
00:08:38,789 --> 00:08:41,659
ಈಗ ನಾವು ಕೊನೆಗೆ ಹೋಗಿ ಮುಂದುವರಿಸಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

152
00:08:41,659 --> 00:08:46,170
ಸಿಹಿ! 4 ಅಪವರ್ತನೀಯ ನಿರೀಕ್ಷೆಯಂತೆ 24 ಮುದ್ರಣ ಮಾಡಿದ.

153
00:08:46,170 --> 00:08:48,690
ಈಗ ನಾವು ನಮ್ಮ ಕೋಡ್ ಈ ಸರಿಪಡಿಸಲು ಹೋಗಬಹುದು.

154
00:08:48,690 --> 00:08:53,710
ಬದಲಿಗೆ GDB ಹೊರಗೆ ಬಿಟ್ಟು ಹೆಚ್ಚು, ನಾವು ಇದನ್ನು ಮತ್ತೊಂದು ಟರ್ಮಿನಲ್ ಟ್ಯಾಬ್ ಬಳಸಿ.

155
00:08:53,710 --> 00:08:58,080
ನಮ್ಮ GDB ಟ್ಯಾಬ್ ಹಿಂದಕ್ಕೆ ಹೋಗಿ, ನಾವು ಈಗ ನಮ್ಮ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮರುಸಂಕಲಿಕೆಯು ಅಗತ್ಯವಿದೆ.

156
00:08:58,080 --> 00:09:03,180
GDB ಬಗ್ಗೆ ಉತ್ತಮ ಕೆಲಸವೆಂದರೆ ನೀವು ಚಲಾಯಿಸಲು GDB ಬಿಡಲು ಅಗತ್ಯವಿಲ್ಲ ಎಂದು.

157
00:09:03,180 --> 00:09:06,570
ಆದ್ದರಿಂದ ನಾವು, ಹಳೆಯ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಡೆಯುವ ಇರಿಸಿಕೊಳ್ಳಲು ಎಂದು

158
00:09:06,570 --> 00:09:10,440
ಈಗ ಅವುಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು, ನೀವು ಊಹಿಸಿದಂತೆ, ಆಜ್ಞೆಯನ್ನು ಅಶಕ್ತಗೊಳಿಸಿ.

159
00:09:10,440 --> 00:09:13,320
ಈ ನಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಎಲ್ಲಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

160
00:09:13,320 --> 00:09:18,180
ಈಗ, ನಾವು R ಕಾರ್ಯಕ್ರಮವನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಎಲ್ಲವೂ ಸರಿಯಾಗಿಯೆ ಖಚಿತವಾಗಿ ಮಾಡಬಹುದು.

161
00:09:18,180 --> 00:09:21,300
ಎಲ್ಲವನ್ನೂ ಹೋಗಲು ಒಳ್ಳೆಯದು ತೋರುತ್ತಿದೆ.

162
00:09:21,300 --> 00:09:24,410
24 ಔಟ್ 4 ಅಚ್ಚುಗಳ ಅಪವರ್ತನೀಯ, ಕೇವಲ ನಾವು ಭಾವಿಸಲಾಗಿದೆ.

163
00:09:24,410 --> 00:09:28,830
GDB ನಿಮ್ಮ ಉಪಕರಣ ರಲ್ಲಿ ಪಡೆದಿರುವಿರಿ ಉಪಯುಕ್ತ ಉಪಕರಣಗಳು ಒಂದಾಗಿದೆ.

164
00:09:28,830 --> 00:09:31,970
>> ನೀವು GDB ಜೊತೆಯಲ್ಲಿ ಮಾಡಬಹುದಾದ ಒಂದು ಟನ್ ಹೆಚ್ಚು ವಿಷಯಗಳನ್ನು ಇವೆ

165
00:09:31,970 --> 00:09:34,030
ನೀವು ಸರಳ ಮುದ್ರಿತಪ್ರತಿಗಳನ್ನು ಜೊತೆಗೆ ಮಾಡಬಹುದು ತುಂಬಾ ಹೆಚ್ಚು.

166
00:09:34,030 --> 00:09:36,730
ಮುಂದಿನ ಬಾರಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ನೀವು ಬಯಸುವ ಏನು ಇಲ್ಲ

167
00:09:36,730 --> 00:09:39,740
ಒಳಗೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು GDB ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ.

168
00:09:39,740 --> 00:09:44,380
ಅಭ್ಯಾಸದ ಸ್ವಲ್ಪ, ನೀವು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನಿಮ್ಮ ದೋಷ ಮೇಲೆ ಕೊರೆತಕ್ಕಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

169
00:09:44,380 --> 00:09:48,180
ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಹೊಂದಿದೆ. ಈ CS50 ಹೊಂದಿದೆ.