1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:] ಹಾಯ್,
ನಾನು [ಮನುಷ್ಯ? ಡಾನ್ Armadaras?].

3
00:00:02,350 --> 00:00:04,410
ಇಂದು, ನಾವು ನೀನು
ಡೀಬಗ್ ನೋಡುವ.

4
00:00:04,410 --> 00:00:06,697
ಕೇವಲ ನಾವು ಹೋಗುವ
ಕೆಲವು ತಂತ್ರಗಳನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡಲು,

5
00:00:06,697 --> 00:00:09,280
ಆದರೆ ನಾವು ನೋಡಲು ನೀನು
ಕೆಲವೊಂದು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಒಳಗೊಂಡಿರುವ

6
00:00:09,280 --> 00:00:14,170
ಅವಕಾಶ ಎಂದು CS50 ಐಡಿಇ ಒಳಗೆ
ನೀವು ಸುಲಭವಾಗಿ ಒಂದು ಪ್ರೋಗ್ರಾಂ ದೋಷ ಗೆ.

7
00:00:14,170 --> 00:00:16,272
>> ಕೇವಲ ಒಂದು ಉದಾಹರಣೆ
ತಪ್ಪು ಹೋಗಿ ಎಂದು ಏನೋ

8
00:00:16,272 --> 00:00:18,730
ಮತ್ತು ಇದು ವಾಸ್ತವವಾಗಿ ವಿಷಯ
ನಾವು ಈಗಾಗಲೇ ಮೊದಲು ನೋಡಿದ.

9
00:00:18,730 --> 00:00:23,200
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಸಿ ಪ್ರೋಗ್ರಾಂ
ನಂತರ, ಬಳಕೆದಾರರ ಒಂದು ಪೂರ್ಣಾಂಕ ಸ್ವೀಕರಿಸುತ್ತದೆ

10
00:00:23,200 --> 00:00:27,580
ಎರಡು ವಿಭಜಿಸಲ್ಪಡುತ್ತದೆ, ಮತ್ತು ಒದಗಿಸುತ್ತದೆ
ಮತ್ತೆ ಬಳಕೆದಾರರಿಗೆ ಔಟ್ಪುಟ್.

11
00:00:27,580 --> 00:00:30,610
ಈಗ ನಾವು ನೋಡಿದ ಎಂಬುದರ
ಹಿಂದಿನ ಉಪನ್ಯಾಸಗಳಲ್ಲಿ,

12
00:00:30,610 --> 00:00:34,370
ನಾವು ಈ ವಾಸ್ತವವಾಗಿ ಕಾರಣವಾಗಬಹುದು ಎಂದು ತಿಳಿಯಲು
ಭಾಗಾಕಾರದ ಸಮಸ್ಯೆಗಳು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ

13
00:00:34,370 --> 00:00:35,860
ನಾವು ಬೆಸ ಸಂಖ್ಯೆಗಳು ಹೊಂದಿರುವಾಗ.

14
00:00:35,860 --> 00:00:40,330
>> ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ದೂರ ಎಸೆಯಲು ಮಾಡುತ್ತೇವೆ
ದಶಮಾಂಶ ಬಿಂದುವಿನ ನಂತರ ಏನು.

15
00:00:40,330 --> 00:00:43,170
ಈಗ, ನಾವು ಈ ತಿಳಿದಿದೆ
ಸಂದರ್ಭದಲ್ಲಿ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ.

16
00:00:43,170 --> 00:00:47,430
ಮತ್ತು ನಾವು ರನ್ ವೇಳೆ, ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ
ಕಂಪೈಲ್ ಮೊದಲ ನಮ್ಮ ಸಂಶಯ,.

17
00:00:47,430 --> 00:00:50,460
ತದನಂತರ, ನಡೆಸುವ ಮೂಲಕ ಮತ್ತು
ಬೆಸ ಸಂಖ್ಯೆಯ ಪ್ರವೇಶಿಸುವ.

18
00:00:50,460 --> 00:00:51,720
>> ಈ ಹೊಸ ಏನೂ ಅಲ್ಲ.

19
00:00:51,720 --> 00:00:54,490
ಆದರೆ ಈ ವಾಸ್ತವವಾಗಿ ಆಗಿದೆ
ಒಂದು ದೋಷವನ್ನು ಉದಾಹರಣೆಯನ್ನು ಎಂದು

20
00:00:54,490 --> 00:00:58,810
ಒಂದು ದೊಡ್ಡ ಕಾರ್ಯಕ್ರಮದ ಒಳಗೆ ಇರುವುದಾಗಿದೆ
ಕೆಳಗೆ ಟ್ರ್ಯಾಕ್ ಕಷ್ಟ ಆಗುತ್ತದೆ.

21
00:00:58,810 --> 00:01:02,640
ನಾವು ಯಾವ ವಿಷಯದ ತಿಳಿಯಲು ಕೂಡ
ವಿಷಯದ ನಿಜವಾದ ತಿರುಳಾಗಿದ್ದು ಆಗಿದೆ

22
00:01:02,640 --> 00:01:06,250
ಗುರುತಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರಬಹುದು
ನಿರ್ದಿಷ್ಟವಾಗಿ ಅಲ್ಲಿ ದೋಷ ಕಂಡುಬರುತ್ತದೆ,

23
00:01:06,250 --> 00:01:09,750
ಏನು ಸಮಸ್ಯೆ ಗುರುತಿಸುವ
, ಮತ್ತು ನಂತರ ಅದನ್ನು ಸರಿಪಡಿಸುವ.

24
00:01:09,750 --> 00:01:14,400
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಯಾಗಿ ಈ ಒದಗಿಸಲು
ಏನೋ ಏನೆಲ್ಲಾ

25
00:01:14,400 --> 00:01:19,030
ನಾವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ಆದರೆ ಸಮಾಧಿ ಎಂದು
ಕೋಡ್ ಇತರ ಅಂಶಗಳನ್ನು ಒಳಗೆ.

26
00:01:19,030 --> 00:01:23,090
>> ಆದ್ದರಿಂದ ಈ ಮೂಲ ತೆರೆಯುವ
ಉದಾಹರಣೆಯಾಗಿ ಕೋಡ್ ಕಡತ,

27
00:01:23,090 --> 00:01:27,165
ಈ ವಿಭಾಗದ ಸಮಸ್ಯೆ ಈಗ
ಒಂದು ಬೃಹತ್ ಯೋಜನೆಯೊಂದರ ಭಾಗವಾಗಿ.

28
00:01:27,165 --> 00:01:29,040
ಇನ್ನೂ ಸ್ವಲ್ಪ ಇರಬಹುದು
ಬಿಟ್ ರೂಪಿಸಲಾದ, ಮತ್ತು ನಾವು

29
00:01:29,040 --> 00:01:31,076
ಸುಲಭವಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ
ವಿಶೇಷವಾಗಿ, ಅದನ್ನು ಗುರುತಿಸಲು

30
00:01:31,076 --> 00:01:32,450
ನಾವು ಈ ಚರ್ಚೆ ಕಾರಣ.

31
00:01:32,450 --> 00:01:38,250
ಆದರೆ ಈ ಎಂದು ಲೆಕ್ಕಾಚಾರ
ಸಮಸ್ಯೆ ಒಂದು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ.

32
00:01:38,250 --> 00:01:45,450
>> ನಾನು ಈ ಕಂಪೈಲ್ ಮತ್ತು ವೇಳೆ
ಇದು, ಒಂದು ಬೆಸ ಸಂಖ್ಯೆ ನಮೂದಿಸಿ ರನ್,

33
00:01:45,450 --> 00:01:49,816
ನಾವು ನಿಖರವಾಗಿ ಇರುವುದಿಲ್ಲ ನೋಡಬಹುದು
ನಾವು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ಔಟ್ಪುಟ್.

34
00:01:49,816 --> 00:01:51,690
ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ,
ನಾವು ಹೇಳಬಹುದು ಎಂದು ನಾವು

35
00:01:51,690 --> 00:01:56,060
ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ ಎಣಿಕೆ ಬಯಸುವ
ಒಂದರಿಂದ ಅಪ್ ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ.

36
00:01:56,060 --> 00:01:58,130
ಮತ್ತು ನಾವು ನಾವು ನೋಡಬಹುದು
ಸಮಸ್ಯೆಗಳ ವಿವಿಧ ಹೊಂದಿವೆ

37
00:01:58,130 --> 00:02:03,880
ನಾವು ಉತ್ಪಾದಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ ಇಲ್ಲಿ ವೇಳೆ, ಕೇವಲ, 0
ಮತ್ತು 1 ನಾವು 5 ಇನ್ಪುಟ್ ಒದಗಿಸಿದಾಗ.

38
00:02:03,880 --> 00:02:07,380
>> ನಾವು ಈಗಾಗಲೇ ತಿಳಿದಿದೆ
ಸಮಸ್ಯೆ ಇಲ್ಲಿ ಇಲ್ಲ.

39
00:02:07,380 --> 00:02:11,662
ಆದರೆ ನಿಖರವಾಗಿ ಗೊತ್ತಿಲ್ಲ
ಅಲ್ಲಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ವಾಸ್ತವವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

40
00:02:11,662 --> 00:02:13,620
ವಿಧಾನಗಳಲ್ಲಿ ಈಗ ಒಂದು
ಈ ಸರಿಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು

41
00:02:13,620 --> 00:02:15,745
ನಾವು ಮಾಡಿದ ವಿಷಯ
ಈಗಾಗಲೇ ಪರಿಚಯಿಸಲಾಗಿದೆ.

42
00:02:15,745 --> 00:02:18,880
ನಾವು ಕೇವಲ ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಬಳಸಬಹುದು.

43
00:02:18,880 --> 00:02:21,680
>> ಸಾಲು 14 ರಲ್ಲಿ, ನಾವು
ಈ printf ಕಾರ್ಯ,

44
00:02:21,680 --> 00:02:25,620
ಇದು ನಮ್ಮ ರಾಜ್ಯದ ಮುದ್ರಿಸುತ್ತದೆ ಅನುಮತಿಸುತ್ತದೆ
ಮಾಹಿತಿಯನ್ನು ವಿವಿಧ ಕಾಯಿಗಳು.

45
00:02:25,620 --> 00:02:28,880
ಮತ್ತು ಈ ವಿಷಯ ನೀವು
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಳಗೆ ಹತೋಟಿ ಮಾಡಬೇಕು

46
00:02:28,880 --> 00:02:33,100
ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಪ್ರಯತ್ನಿಸಿ
ಕೋಡ್ ವಿವಿಧ ಸಾಲುಗಳನ್ನು ನಡೆಯುತ್ತಿದೆ.

47
00:02:33,100 --> 00:02:36,350
ಆದ್ದರಿಂದ ಈ ಇದ್ದರೂ
ಅಂತಿಮ ಔಟ್ಪುಟ್ ನಾವು ವಾಸ್ತವವಾಗಿ

48
00:02:36,350 --> 00:02:39,830
ಹೊರಗೆ ತಯಾರಿಸಲು ಬಯಸುವ
ಈ ಪ್ರೋಗ್ರಾಂ, ನಾವು ಇನ್ನೂ

49
00:02:39,830 --> 00:02:42,300
ಕೆಲವು ಡಿಬಗ್ ಹೊಂದಿರಬಹುದು
ಹೇಳಿಕೆಗಳನ್ನು ಅಲ್ಲಿ ನಾವು

50
00:02:42,300 --> 00:02:46,970
ಲೆಕ್ಕಾಚಾರ ಪ್ರಯತ್ನಿಸಬಹುದು ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ
ನಮ್ಮ ಕೋಡ್ ಒಳಗೆ ನಡೆಯುತ್ತಿದೆ.

51
00:02:46,970 --> 00:02:51,210
>> ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದನ್ನೇ ತಿನ್ನುವೆ
ಡಿಬಗ್ ಟ್ಯಾಗ್ printf.

52
00:02:51,210 --> 00:02:53,540
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ
ಕೇವಲ ಒಂದು ಡಿಬಗ್ ಸ್ಟ್ರಿಂಗ್

53
00:02:53,540 --> 00:02:56,840
ನಾನು-ಹಾಕುವ ಆದ್ದರಿಂದ ಆಗುತ್ತದೆ ಮನುಷ್ಯ
ನನ್ನ ಕೋಡ್ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ

54
00:02:56,840 --> 00:02:59,200
ಏನು ನಾನು ತೋರಿಸಲು ಬಯಸುವ ಆಗಿದೆ.

55
00:02:59,200 --> 00:03:04,410
ಸಂಖ್ಯೆ ಇಲ್ಲಿ ಮತ್ತು ಔಟ್ಪುಟ್
ನಾವು ಲೆಕ್ಕಾಚಾರ ಎಂದು.

56
00:03:04,410 --> 00:03:06,800
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಬಹುಶಃ
ನಿಖರವಾಗಿ ತಿಳಿಯುವ

57
00:03:06,800 --> 00:03:11,380
ಏನು ಮುಂಚಿತವಾಗಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂದು ಮತ್ತು
ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಗಣನಾ ನಂತರ.

58
00:03:11,380 --> 00:03:16,224
ಹಾಗಾಗಿ ಮೊದಲು ಒಂದು printf ಬಳಸಬಹುದು
ಮತ್ತು ಕೋಡ್ ಆಫ್ ಸಾಲನ್ನು ನಂತರ.

59
00:03:16,224 --> 00:03:18,640
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಸಾಧ್ಯವೋ
ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ಪಷ್ಟಪಡಿಸಲು

60
00:03:18,640 --> 00:03:21,960
ಮೊದಲು ಡಿಬಗ್ ಹೇಳುವ ಮೂಲಕ
ಮತ್ತು ಡಿಬಗ್ ಆದ್ದರಿಂದ ನಂತರ

61
00:03:21,960 --> 00:03:26,540
ನಾನು ನಾನೇ ಗೊಂದಲ ಇಲ್ಲ ಎಂದು
ತೆರನಾಗಿ ಅನೇಕ ಸಾಲುಗಳ.

62
00:03:26,540 --> 00:03:32,290
>> ಈಗ ನಾವು ಈ ಮತ್ತು ರನ್ ಮರುಸಂಕಲಿಕೆಯು ವೇಳೆ
ಇದು, ಮತ್ತೆ ಐದು ಒಂದು ಸಂಖ್ಯೆ ನಮೂದಿಸಿ

63
00:03:32,290 --> 00:03:35,090
ನಾವು ಹೊಂದಿರುವ ನೋಡಬಹುದು
ಈಗ ಮೊದಲು ಮತ್ತು ನಂತರ ಔಟ್ಪುಟ್

64
00:03:35,090 --> 00:03:40,670
ಮತ್ತು ನಾವು ಒಂದು ಸ್ಪಷ್ಟ ಮಾಡದಿದ್ದರೆ ಎಂದು ಹೇಗೆ
ವಿಭಾಗ ಅಥವಾ ಸ್ಪಷ್ಟ ಸಂಖ್ಯೆಯ ಹೊಂದಿರುವ

65
00:03:40,670 --> 00:03:43,680
ನಾವು ವಾಸ್ತವವಾಗಿ ಬಯಸುವ.

66
00:03:43,680 --> 00:03:48,660
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ
ನಿಜವಾಗಿಯೂ ಸ್ಪಷ್ಟ ಔಟ್ಪುಟ್.

67
00:03:48,660 --> 00:03:52,440
ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು ಸ್ಪಷ್ಟ ಫಲಿತಾಂಶದ ಅಲ್ಲ
ಈ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ ಬಯಸುವ.

68
00:03:52,440 --> 00:03:54,427
>> ಮತ್ತು ಈ ಒಂದು, ಮತ್ತೆ,
ಸ್ವಲ್ಪ ರೂಪಿಸಲಾದ.

69
00:03:54,427 --> 00:03:57,510
ಆದರೆ, ಬಹುಶಃ, ಎಂಬುದೂ ಒಂದು
ವಿವರಣೆಯನ್ನು ಹೇಳಿದರು ವೇಳೆ ನಾವು ಮಾಡಬಹುದಾದ

70
00:03:57,510 --> 00:04:01,900
ನಾವು ಈ ವಿಭಜನೆಯನ್ನು ಬಯಸುವ
2 ಮತ್ತು ಆದ್ದರಿಂದ ಇತರ ಪದಗಳಲ್ಲಿ 1 ಹೊಂದಿವೆ ಸೇರಿಸಿ

71
00:04:01,900 --> 00:04:04,550
ನಾವು ನಂತರ ಕ್ಯಾಲ್ಗರಿಯಲ್ಲಿದೆ ಹಿಡಿಯಲು ಬಯಸುತ್ತೇನೆ
ನಾವು ಎಂದು ತಿಳಿದಿರುವ ಇರಬಹುದು

72
00:04:04,550 --> 00:04:08,060
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ವಿಷಯವನ್ನು.

73
00:04:08,060 --> 00:04:14,010
ಈಗ ಇಲ್ಲಿ ನಾವು ಎಂದು ತಿಳಿದಿರುವ
ನಮ್ಮ ಅರ್ಧಮಟ್ಟಕ್ಕಿಳಿಸಲಾಯಿತು ಸಂಖ್ಯೆಗೆ 1 ಸೇರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

74
00:04:14,010 --> 00:04:16,490
>> ಈ ಮರುಸಂಕಲಿಕೆಯು ಲೆಟ್
ಮತ್ತು ಈ ದೃಢೀಕರಿಸಿ

75
00:04:16,490 --> 00:04:18,860
ನಾವು ಬಯಸುವ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುವುದರ.

76
00:04:18,860 --> 00:04:21,980
ನಾವು ಈಗ ಮೊದಲು ನೋಡಬಹುದು
ಹೊಂದಿರುವ, ನಾವು ಸಂಖ್ಯೆ 5.

77
00:04:21,980 --> 00:04:26,620
ನಂತರ, ನಾವು, ಸಂಖ್ಯೆ 3
ನಮ್ಮ ವಿವರಣೆಯನ್ನು ಪ್ರಕಾರ,

78
00:04:26,620 --> 00:04:29,292
ನಾವು ಮಾಡಲು ಬಯಸಿದ್ದರು ಏನು.

79
00:04:29,292 --> 00:04:31,000
ಆದರೆ ನಾವು ನೋಡಿದರೆ
ಇಲ್ಲಿ ಉತ್ಪಾದನೆ, ನಾವು

80
00:04:31,000 --> 00:04:33,760
ನಾವು ಮತ್ತೊಂದು ಹೊಂದಿರಬಹುದೆಂದು ನೋಡಿ
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ದೋಷ,

81
00:04:33,760 --> 00:04:36,940
ನಾವು 0 ನಮ್ಮ ಎಣಿಕೆ ಆರಂಭಿಕ ಎಂದು.

82
00:04:36,940 --> 00:04:39,390
>> ಈಗ ಮತ್ತೆ, ಈ ವಿಷಯ
ನಾವು ಹಿಂದೆ ಕಂಡ

83
00:04:39,390 --> 00:04:42,500
ಮತ್ತು ನಾವು ಸಾಕಷ್ಟು ಸುಲಭವಾಗಿ ಬಗೆಹರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

84
00:04:42,500 --> 00:04:44,790
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು
ಸಹ ಲಾಭ ಹೊಂದಿತ್ತು

85
00:04:44,790 --> 00:04:48,940
printf ಹೇಳಿಕೆ ಬಳಸುವ
ನೇರವಾಗಿ ಲೂಪ್ ಒಳಗೆ

86
00:04:48,940 --> 00:04:52,930
ನಿಖರವಾಗಿ ಅಲ್ಲಿ ತಿಳಿಯಲು
ದೋಷ ಸಂಭವಿಸುವ.

87
00:04:52,930 --> 00:04:55,150
ಆದ್ದರಿಂದ printf ಹೇಳಿಕೆಗಳು ಇವೆ
ಸಹಾಯ ಬಹಳ ಉಪಯುಕ್ತ

88
00:04:55,150 --> 00:04:57,940
ನೀವು ಅಲ್ಲಿ ನಿರ್ಧರಿಸಲು,
ನಿಖರವಾಗಿ ನಿಮ್ಮ ಮೂಲ ಕೋಡ್,

89
00:04:57,940 --> 00:05:00,620
ನಿರ್ದಿಷ್ಟ ದೋಷ ಸಂಭವಿಸುತ್ತಿದೆ.

90
00:05:00,620 --> 00:05:03,650
>> ಮತ್ತು ಅದನ್ನು ಸಾಧಿಸುವುದಕ್ಕಾಗಿ ಕೂಡ ಪ್ರಮುಖ
ಎಂದು, ನಾವು ಕೋಡ್ ಬರೆಯಲು ನೀವು,

91
00:05:03,650 --> 00:05:06,052
ನಾವು ಊಹೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು
ಒಂದು ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಬಗ್ಗೆ.

92
00:05:06,052 --> 00:05:08,510
ಅಥವಾ ನಾವು ಊಹೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು
ಕಾರ್ಯಕ್ರಮದ ಯಾವ ಭಾಗ ಬಗ್ಗೆ

93
00:05:08,510 --> 00:05:13,020
ವಾಸ್ತವವಾಗಿ ಸರಿಯಾದ ಅಥವಾ ತಪ್ಪು
ನಂತರ ನಾವು ಪ್ರೋಗ್ರಾಂ ಮೇಲೆ ನಿರ್ಮಿಸಲು

94
00:05:13,020 --> 00:05:15,950
ಮತ್ತು ಇದು ಒಂದು ಭಾಗವಾಗಿ ಮಾಡಲು
ಸಂಕೀರ್ಣ ಮತ್ತು ದೊಡ್ಡ ಕಾರ್ಯಕ್ರಮದ

95
00:05:15,950 --> 00:05:19,700
ನಾವು ಕೆಲವು ವಿಷಯಗಳನ್ನು ಅರ್ಥ
ನಿಜವಾಗಿ ದೋಷಯುಕ್ತ ಹೊಂದಿದೆ.

96
00:05:19,700 --> 00:05:22,680
>> Printf ಬಳಸಿಕೊಂಡು ನಿಜವಾಗಿಯೂ ಸಹಾಯ ಮಾಡಬಹುದು
ಕಿರಿದುಗೊಳಿಸಿ ಮತ್ತು ಗುರುತಿಸಲು

97
00:05:22,680 --> 00:05:26,430
ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಪ್ರದೇಶಗಳ ಮಾಡದಿರಬಹುದು
ನಿಖರವಾಗಿ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುವ ಎಂದು ನಾವು

98
00:05:26,430 --> 00:05:29,500
ನಮ್ಮ ಊಹೆಗಳನ್ನು ಆಧರಿಸಿ, ನಿರೀಕ್ಷಿಸಬಹುದು.

99
00:05:29,500 --> 00:05:31,460
ಆದರೆ ಇತರ ಉಪಕರಣಗಳು ಇಲ್ಲ
ಲಭ್ಯವಿದ್ದು,,

100
00:05:31,460 --> 00:05:34,860
ಎಂದು ನಮಗೆ ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಅವಕಾಶ
ಅಲ್ಲಿ ದೋಷ ಸಂಭವಿಸುತ್ತಿದೆ ಔಟ್

101
00:05:34,860 --> 00:05:39,930
ಮತ್ತು, ವಿಶೇಷವಾಗಿ, ಯಾವ ವಿಷಯಗಳು
ಕಾರ್ಯಕ್ರಮದ ಒಳಗೆ ಸಂಭವಿಸುತ್ತಿವೆ.

102
00:05:39,930 --> 00:05:41,990
>> ಆದ್ದರಿಂದ ಬಳಸಿಕೊಂಡು printf ಬಹಳ
ಉಪಯುಕ್ತ ನಾವು ಬಯಸುವ

103
00:05:41,990 --> 00:05:45,900
ನಿರ್ದಿಷ್ಟ ಪ್ರದೇಶಗಳಲ್ಲಿ ಗುರುತಿಸಲು
ಕೆಲವು ದೋಷ ಹೊಂದಿರುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ.

104
00:05:45,900 --> 00:05:47,730
ಆದರೆ ಇದು ಆಗುತ್ತದೆ
ಸ್ವಲ್ಪ ನಂತರ ಬೇಸರದ.

105
00:05:47,730 --> 00:05:50,500
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಒಂದು ಆಗಿದೆ
ಸರಳ ಪ್ರೋಗ್ರಾಂ

106
00:05:50,500 --> 00:05:52,750
ಕೇವಲ ಒಂದು ಅಥವಾ ಎರಡು ಅಸ್ಥಿರ.

107
00:05:52,750 --> 00:05:57,260
ಮತ್ತು ಇದು ನಮಗೆ ತುಂಬಾ ಸುಲಭ ಆಗುತ್ತದೆ
ಆ ಅಸ್ಥಿರ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ

108
00:05:57,260 --> 00:05:59,670
ದೊಡ್ಡ ಕಾರ್ಯಕ್ರಮದ ಸಂದರ್ಭದಲ್ಲಿ.

109
00:05:59,670 --> 00:06:02,670
>> ಆದರೆ ನಾವು ಬೇರೆ ಹೊಂದಿರಬಹುದು
ವ್ಯತ್ಯಯಗಳನ್ನು ಹೊಂದಿದೆ ಪ್ರೋಗ್ರಾಂ.

110
00:06:02,670 --> 00:06:06,530
ಮತ್ತು ಅದು ಸಾಕಷ್ಟು ಇರಬಹುದು
printf ಬಳಸಲು ಆದ್ದರಿಂದ ಸುಲಭ

111
00:06:06,530 --> 00:06:10,120
ಏನು ನಡೆಯುತ್ತಿದೆ ಮೌಲ್ಯಮಾಪನ ಪ್ರಯತ್ನಿಸಿ
ಆ ಅಸ್ಥಿರ ಪ್ರತಿ ಒಂದು

112
00:06:10,120 --> 00:06:13,590
ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಇದೆ.

113
00:06:13,590 --> 00:06:16,960
ಅಂದಿನ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಇಲ್ಲ
ದೋಷನಿವಾರಕದ ಪ್ರೋಗ್ರಾಂ ಎಂದು.

114
00:06:16,960 --> 00:06:20,320
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ನಾವು ತಿನ್ನುವೆ
ಬಳಕೆ, GDB ಗ್ನೂ ದೋಷಸೂಚಕವು, ಅಥವಾ

115
00:06:20,320 --> 00:06:24,260
ಎಂದು ನಮಗೆ ಆಂತರಿಕ ಪರೀಕ್ಷಿಸಲು ಅನುಮತಿಸುತ್ತದೆ
ಹೆಚ್ಚು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಕೆಲಸಗಳ

116
00:06:24,260 --> 00:06:25,700
ವಿವರವಾದ ರೀತಿಯಲ್ಲಿ.

117
00:06:25,700 --> 00:06:28,810
>> ನಾವು ನಿಜವಾಗಿಯೂ ನಿರ್ವಹಿಸಬಲ್ಲದು
ಆಜ್ಞಾ ಸಾಲಿನಿಂದ GDB

118
00:06:28,810 --> 00:06:35,370
ಇಲ್ಲಿ ಕೇವಲ GDB ಮತ್ತು ನಮೂದಿಸಿ
ನಾವು ದೋಷ ಬಯಸುವ ಆದೇಶ.

119
00:06:35,370 --> 00:06:37,550
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎಣಿಕೆ.

120
00:06:37,550 --> 00:06:41,650
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೋಡಬಹುದು
GDB ಹೇಳುತ್ತದೆ ಒಂದು ಪ್ರಾಂಪ್ಟ್ ನಮಗೆ ತೆರೆದಿಡುತ್ತದೆ.

121
00:06:41,650 --> 00:06:44,020
ಮತ್ತು ನಾವು ವಾಸ್ತವವಾಗಿ ಮಾಡಬಹುದು
GDB ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ

122
00:06:44,020 --> 00:06:48,260
ವಾಸ್ತವವಾಗಿ ಮರಣದಂಡನೆ ಆರಂಭಿಸಲು
ಪ್ರೋಗ್ರಾಂ, ಕೆಲವು ಕಡೆಗಳಲ್ಲಿ ಇದನ್ನು ನಿಲ್ಲಿಸಲು,

123
00:06:48,260 --> 00:06:51,060
ಅಸ್ಥಿರ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು
ಅಸ್ಥಿರ ಪರೀಕ್ಷಿಸಲು ಎಂದು

124
00:06:51,060 --> 00:06:54,152
ಪ್ರೋಗ್ರಾಂ ಸ್ಥಿತಿಯಲ್ಲಿವೆ
ಆ ಕ್ಷಣದಲ್ಲಿ ಆ,

125
00:06:54,152 --> 00:06:55,110
ಹೀಗೆ ಇತ್ಯಾದಿ.

126
00:06:55,110 --> 00:06:57,240
ಇದು ನಮಗೆ ಶಕ್ತಿ ಸಾಕಷ್ಟು ಒದಗಿಸುತ್ತದೆ.

127
00:06:57,240 --> 00:06:59,960
>> ಆದರೆ ಇದು ಕೇವಲ ಹಾಗೆ ನಡೆಯುತ್ತದೆ
ಸಹ, CS50 ಐಡಿಇ

128
00:06:59,960 --> 00:07:05,870
ಒಂದು GUI ಅಥವಾ ಬಳಕೆದಾರರು ಒದಗಿಸುತ್ತದೆ
GDB ಇಂಟರ್ಫೇಸ್ ಎಂದು

129
00:07:05,870 --> 00:07:11,120
ನಮಗೆ ಅಗತ್ಯವಿಲ್ಲದೇ ಈ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ
ಇಲ್ಲ ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ ಫೇಸ್

130
00:07:11,120 --> 00:07:13,560
ಅಥವಾ ಸಮರ್ಪಕವಾಗಿಲ್ಲ.

131
00:07:13,560 --> 00:07:16,930
ನಾನು ಪ್ರವೇಶಿಸಬಹುದು ರೀತಿಯಲ್ಲಿ
ಡಿಬಗ್ ಬಟನ್ ಬಳಸಿ ಹೊಂದಿದೆ

132
00:07:16,930 --> 00:07:20,120
CS50 ಐಡಿಇ ತುದಿಯನ್ನು.

133
00:07:20,120 --> 00:07:24,280
ಈಗ ಹಿಂದೆ, ನಾವು ಹೊಂದಿವೆ
ನೋಡಿದ ನಾವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಎಂದು

134
00:07:24,280 --> 00:07:27,660
ಲೈನ್ ಕಂಪೈಲ್ ತದನಂತರ ಪ್ರೋಗ್ರಾಮ್.

135
00:07:27,660 --> 00:07:29,790
>> ಡಿಬಗ್ ಬಟನ್ ಮಾಡುತ್ತದೆ
ಆ ಕ್ರಮಗಳನ್ನು ಎರಡೂ.

136
00:07:29,790 --> 00:07:34,380
ಆದರೆ ಇದು ತರುವ
ಬಲಪಂಥೀಯ ದೋಷಸೂಚಕವು ಟ್ಯಾಬ್

137
00:07:34,380 --> 00:07:38,280
ಎಂದು ನಮಗೆ ವಿವಿಧ ಪರೀಕ್ಷಿಸಲು ಅನುಮತಿಸುತ್ತದೆ
ಪ್ರೋಗ್ರಾಂ ಗುಣಗಳನ್ನು

138
00:07:38,280 --> 00:07:40,500
ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಇದೆ.

139
00:07:40,500 --> 00:07:44,280
ನಾನು ಈ ಡೀಬಗ್ ಕ್ಲಿಕ್ ಮಾಡಿದರೆ
ಸಂದರ್ಭದಲ್ಲಿ, ಅದನ್ನು ತರುವ

140
00:07:44,280 --> 00:07:48,230
ಕನ್ಸೋಲಿನಲ್ಲಿ ಹೊಸ ಟ್ಯಾಬ್
ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ ವಿಂಡೋ.

141
00:07:48,230 --> 00:07:51,160
>> ಮತ್ತು ನೀವು ಈ ಟ್ಯಾಬ್ ಹೊಂದಿದೆ ನೋಡಬಹುದು
ತುದಿಯನ್ನು ಕೆಲವು ಮಾಹಿತಿ.

142
00:07:51,160 --> 00:07:52,670
ಮತ್ತು ನಾವು ಹೆಚ್ಚಾಗಿ ಈ ನಿರ್ಲಕ್ಷಿಸಬಹುದು.

143
00:07:52,670 --> 00:07:54,800
ಆದರೆ ವಸ್ತುಗಳ ಒಂದು
ನಾವು ಗಮನಕ್ಕೆ ಬಯಸುವ

144
00:07:54,800 --> 00:07:57,170
ಅದು ಹೊರತರುವ ಎಂಬುದು
ಒಂದೇ ಎಂದು ನಾವು

145
00:07:57,170 --> 00:08:03,000
ನಾವು ಮಾಡಲು ಔಟ್ ಪ್ರಯತ್ನಿಸಿದ ವೇಳೆ ಹೋಗಬಹುದು
ಆದೇಶತೆರೆಯ ಸಿ ಪ್ರೋಗ್ರಾಂ.

146
00:08:03,000 --> 00:08:06,230
>> ಇಲ್ಲಿ, ನಾವು ಖಣಿಲು ಚಾಲನೆಯಲ್ಲಿರುವ ನೋಡಬಹುದು,
ಮತ್ತು ಇದು ಧ್ವಜಗಳು ವಿವಿಧ ಹೊಂದಿದೆ,

147
00:08:06,230 --> 00:08:12,660
ಮತ್ತು ಇದು ನಮ್ಮ count.c ಕಡತ ಕಂಪೈಲ್ ಇದೆ
ಇದು ಸಮಯದಲ್ಲಿ ಆಯ್ಕೆ ಟ್ಯಾಬ್ ಆಗಿತ್ತು

148
00:08:12,660 --> 00:08:15,100
ನಾನು ಡಿಬಗ್ ಹಿಟ್.

149
00:08:15,100 --> 00:08:18,010
ಆದ್ದರಿಂದ ಈ ಏಕೆಂದರೆ ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ
ಈಗ ಈ ಡಿಬಗ್ ಬಟನ್ ಬಳಸಿ,

150
00:08:18,010 --> 00:08:23,280
ನಾವು ಏಕಕಾಲದಲ್ಲಿ ನಂತರ ಸಂಕಲಿಸಲು ಮತ್ತು ಮಾಡಬಹುದು
ಕಾರ್ಯಕ್ರಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು ವಾಸ್ತವವಾಗಿ

151
00:08:23,280 --> 00:08:24,460
ಚಲಾಯಿಸಲು ಬಯಸುವ.

152
00:08:24,460 --> 00:08:27,880
>> ಎಂದು ಗುರುತುಗಳ ಒಂದು
ಪ್ರಮುಖ, ಈ ಸಂದರ್ಭದಲ್ಲಿ,

153
00:08:27,880 --> 00:08:30,190
ನಾವು ವಾಸ್ತವವಾಗಿ ಬಳಸಿಕೊಂಡು ಬಂದಿದೆ
ದೀರ್ಘ ಕಾಲ

154
00:08:30,190 --> 00:08:32,450
ಆದರೆ ಕೇವಲ ಕೆಲವು ಕೈ ಮಾಡಿದರು
ಬೀಸುವ [ಕೇಳಿಸುವುದಿಲ್ಲ], ಇದು

155
00:08:32,450 --> 00:08:33,820
ಇಲ್ಲಿಯೇ ಈ ಒಂದಾಗಿದೆ.

156
00:08:33,820 --> 00:08:35,790
ಖಣಿಲು, ಇದು -ggdb3 ಹೇಳುತ್ತಾರೆ.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಏನು
ಖಣಿಲು ಹೇಳುವ, ನಮ್ಮ ಕಂಪೈಲರ್,

159
00:08:41,250 --> 00:08:43,820
ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ.

160
00:08:43,820 --> 00:08:46,810
ಆದರೆ ಯಾವುವು ಒದಗಿಸಲು
ಎಂಬ ಸಂಕೇತವಾಗಿ ಮಾಹಿತಿ

161
00:08:46,810 --> 00:08:50,940
ಕಂಪೈಲರ್ ವಾಸ್ತವವಾಗಿ ಪ್ರವೇಶ ಎಂದು ಆದ್ದರಿಂದ
ಆಧಾರವಾಗಿರುವ ಮಾಹಿತಿ ಬಹಳಷ್ಟು

162
00:08:50,940 --> 00:08:52,610
ಪ್ರೋಗ್ರಾಂ ಇರುವ.

163
00:08:52,610 --> 00:08:55,260
>> ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಸಂಖ್ಯೆ
ನಾನು ಕಾರ್ಯಗಳ,

164
00:08:55,260 --> 00:08:58,000
ಆ ಕಾರ್ಯಗಳನ್ನು ಹೆಸರುಗಳು,
ಚರಾಂಕಗಳ ರೀತಿಯ

165
00:08:58,000 --> 00:09:01,730
ಆ ಅಸ್ಥಿರ, ಮತ್ತು ವಿವಿಧ ಎಂದು
ದೋಷನಿವಾರಕದ ಸಹಾಯ ಇತರ ವಸ್ತುಗಳ

166
00:09:01,730 --> 00:09:04,350
ತನ್ನ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸಲು.

167
00:09:04,350 --> 00:09:06,600
ಈಗ ಬೇರೆಯದರಲ್ಲಿ ಇಲ್ಲ
ಎಂದು ನಮೂದಿಸುವುದನ್ನು ಪ್ರಮುಖ

168
00:09:06,600 --> 00:09:10,280
ನಾವು ಚಾಲನೆಯಲ್ಲಿರುವ ಚರ್ಚೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಈ ರೀತಿಯಲ್ಲಿ ಒಂದು ಪ್ರೋಗ್ರಾಂ.

169
00:09:10,280 --> 00:09:13,660
>> ಇದು ವಾಸ್ತವವಾಗಿ ಹೊಂದಿದೆ ಗಮನಕ್ಕೆ
ನಮ್ಮ ಕನ್ಸೋಲ್ ಹೊಸ ಟ್ಯಾಬ್ ಬೆಳೆದರು

170
00:09:13,660 --> 00:09:14,780
ತಳದಲ್ಲಿ.

171
00:09:14,780 --> 00:09:18,600
ನಾವು ಇನ್ನು ಮುಂದೆ ವ್ಯವಹರಿಸಲು
ನೇರವಾಗಿ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ.

172
00:09:18,600 --> 00:09:21,420
ಆದರೆ ಈ ಹೊಸ ಟ್ಯಾಬ್
ವಾಸ್ತವವಾಗಿ ಒಂದು ಟರ್ಮಿನಲ್ ವಿಂಡೋವನ್ನು.

173
00:09:21,420 --> 00:09:26,710
ಇದು ಕೇವಲ ಚಾಲನೆಯಲ್ಲಿರುವ ನಿರ್ದಿಷ್ಟವಾಗಿರುತ್ತದೆ
ನಾವು ರಚಿಸಿದ ಪ್ರೋಗ್ರಾಂ.

174
00:09:26,710 --> 00:09:29,270
>> ರಲ್ಲಿ, ಕೆಳಭಾಗದಲ್ಲಿ ಗಮನಿಸಿ
ಕೆಲವು ಔಟ್ಪುಟ್ ಸಂಯೋಜನೆಯೊಂದಿಗೆ

175
00:09:29,270 --> 00:09:33,500
ಕಂಪೈಲರ್ ಮತ್ತು GDB ಖಣಿಲು ಮೂಲಕ
ನಾವು ಹೆಚ್ಚಾಗಿ ನಿರ್ಲಕ್ಷಿಸಬಹುದು ಇದು,

176
00:09:33,500 --> 00:09:37,570
ನಿಜವಾಗಿ ಔಟ್ಪುಟ್ ತೋರಿಸುತ್ತದೆ
ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ.

177
00:09:37,570 --> 00:09:41,240
ಈಗ ಅರ್ಥ ಮುಖ್ಯ
ವಾಸ್ತವವಾಗಿ ಈ ಒಂದು ವಿಂಡೋ

178
00:09:41,240 --> 00:09:43,360
ನೀವು ತೋರಿಸುತ್ತದೆ
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಉತ್ಪತ್ತಿಯನ್ನು

179
00:09:43,360 --> 00:09:47,190
ಆದರೆ ಆದಾನವನ್ನು ಸ್ವೀಕರಿಸಬಲ್ಲ
ಆ ಪ್ರೋಗ್ರಾಂ, ಜೊತೆಗೆ.

180
00:09:47,190 --> 00:09:49,260
>> ಆದ್ದರಿಂದ ಹೇಳುತ್ತದೆ ಸೂಚನೆ
ದಯವಿಟ್ಟು ಸಂಖ್ಯೆ ನಮೂದಿಸಿ,

181
00:09:49,260 --> 00:09:53,050
ಇದು ನಾವು ಎಂದು ಅದೇ ಉತ್ಪನ್ನ
ಮೊದಲು ಆದೇಶತೆರೆಯ ಹೊಂದಿತ್ತು.

182
00:09:53,050 --> 00:09:55,510
ಆದರೆ ಈಗ ಈ ಹೊಸ ಟ್ಯಾಬ್ನಲ್ಲಿ ತೋರಿದ್ದಾಳೆ.

183
00:09:55,510 --> 00:09:56,550
ನಾನು ಇನ್ಪುಟ್ ಒಂದು ಸಂಖ್ಯೆ ಮಾಡಬಹುದು.

184
00:09:56,550 --> 00:10:00,900
ಮತ್ತು ಇದು ವಾಸ್ತವವಾಗಿ ತಿನ್ನುವೆ
ಕಾರ್ಯ ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು

185
00:10:00,900 --> 00:10:05,890
ನಮಗೆ ನಮ್ಮ ಡಿಬಗ್ ತೋರಿಸುವ, ಔಟ್ಪುಟ್,
ದೋಷಯುಕ್ತ ಎಂದು ಔಟ್ಪುಟ್,

186
00:10:05,890 --> 00:10:07,010
ಎಂದು ನಾವು ಮೊದಲು ನೋಡಿದ.

187
00:10:07,010 --> 00:10:10,460
ಮತ್ತು ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ, ಇದು
ವಾಸ್ತವವಾಗಿ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಂದಿದೆ

188
00:10:10,460 --> 00:10:14,550
ಜಿಡಿಪಿ ಕೇವಲ ಎಂದು
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಪೂರ್ಣಗೊಂಡ.

189
00:10:14,550 --> 00:10:16,655
>> ಈಗ ನೀವು ಈ ಕಂಡಿದ್ದರಿಂದ
ಮೂಲಕ ನಿರ್ದಿಷ್ಟ ರನ್,

190
00:10:16,655 --> 00:10:19,370
ಇದು ವಿಶೇಷವಾಗಿ ಅಲ್ಲ
ಉಪಯುಕ್ತ ಕಾರಣ

191
00:10:19,370 --> 00:10:23,740
ನಾವು ಸಹ ದೋಷಸೂಚಕವು ಮೆನು ಬರುತ್ತದೆ
ಅಪ್, ಈ ಇನ್ನೂ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಕ್ರಮವಾಗಿತ್ತು.

192
00:10:23,740 --> 00:10:26,790
ಯಾವುದೇ ಹಂತದಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಮಾಡಿದರು
ನಮಗೆ ಮರಣದಂಡನೆ ವಿರಾಮ

193
00:10:26,790 --> 00:10:30,767
ಎಲ್ಲಾ ಪರೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ
ಅಸ್ಥಿರ ಇರುವ.

194
00:10:30,767 --> 00:10:32,850
ಬೇರೆಯದರಲ್ಲಿ ಇಲ್ಲ
ನಾವು ಸಲುವಾಗಿ ಮಾಡಬೇಕು

195
00:10:32,850 --> 00:10:36,910
ನಾವು ಬಯಸುವ ಎಂದು ಗುರುತಿಸಲು GDB ಪಡೆಯಲು
ಕಾರ್ಯಕ್ರಮದ ತಾತ್ಕಾಲಿಕ

196
00:10:36,910 --> 00:10:42,820
ಮತ್ತು ಅದನ್ನು ಮುಂದುವರಿಯಲು ಅವಕಾಶ
ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ಬಯಸುವ.

197
00:10:42,820 --> 00:10:45,530
>> ಮರಣದಂಡನೆ ತಾತ್ಕಾಲಿಕ ಸಲುವಾಗಿ,
ಕೆಲವು ನಿರ್ದಿಷ್ಟ ರೇಖೆಯನ್ನು,

198
00:10:45,530 --> 00:10:47,830
ನಾವು ಇಲ್ಲಿದೆ ರಚಿಸಬೇಕಾಗಿದೆ
ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಎಂಬ.

199
00:10:47,830 --> 00:10:52,670
ಮತ್ತು ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಬಹಳ ಸುಲಭವಾಗಿ ರಚಿಸಲಾಗಿದೆ
ಈ ನಿಮ್ಮ ಮೌಸ್ ಪಡೆದುಕೊಂಡು ಐಡಿಇ CS50

200
00:10:52,670 --> 00:10:57,090
ಮತ್ತು ಎಡಕ್ಕೆ ನೇರವಾಗಿ ಕ್ಲಿಕ್
ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಾಲಿನ ಸಂಖ್ಯೆಯ.

201
00:10:57,090 --> 00:10:59,920
ನಾನು ಹಾಗೆ, ಒಂದು ಕೆಂಪು ಬಿಂದುವನ್ನು
ಸೂಚಿಸುತ್ತದೆ, ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ

202
00:10:59,920 --> 00:11:02,300
ಆ ಸಾಲು ಈಗ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಆಗಿದೆ.

203
00:11:02,300 --> 00:11:07,540
>> ನಾನು GDB ರನ್ ಮುಂದಿನ ಬಾರಿ, ಇದು
ಎಂದು ಬ್ರೇಕ್ ಹಂತದಲ್ಲಿ ಮರಣದಂಡನೆ ನಿಲ್ಲಿಸಿ

204
00:11:07,540 --> 00:11:10,280
ಇದು ಕೋಡ್ ಆಫ್ ಸಾಲನ್ನು ತಲುಪಿದಾಗ.

205
00:11:10,280 --> 00:11:12,230
ಈಗ ಈ ಮುಖ್ಯ
ವಿಷಯ ಅರ್ಥ

206
00:11:12,230 --> 00:11:16,140
ಇದು ಅಲ್ಲ ಎಂದು ಅಗತ್ಯವಾಗಿ
ಸಂದರ್ಭದಲ್ಲಿ ಆ ಕೋಡ್ ಪ್ರತಿಯೊಂದು ಸಾಲು

207
00:11:16,140 --> 00:11:17,880
ವಾಸ್ತವವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದಾಗಿದೆ.

208
00:11:17,880 --> 00:11:23,780
ನಾನು ಕಾರ್ಯ ರಚಿಸಲು ವೇಳೆ
ಇಲ್ಲಿ, ಉದಾಹರಣೆಗೆ ನಿರರ್ಥಕ ಎಫ್ ಫಾರ್

209
00:11:23,780 --> 00:11:31,230
ಮತ್ತು ಹಲೋ ಇಲ್ಲಿ ಒಂದು ಮುದ್ರಣ ಸಾಲನ್ನು ಮಾಡಲು
ವಿಶ್ವದಲ್ಲೇ ನಾನು ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯಲು ಎಂದಿಗೂ ವೇಳೆ,

210
00:11:31,230 --> 00:11:34,770
ಇದು ಸಂದರ್ಭದಲ್ಲಿ ಎಂದು,
ನಾನು ಇಲ್ಲಿ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್ ವೇಳೆ,

211
00:11:34,770 --> 00:11:36,220
ಕಾರ್ಯ ಎಂದು ಎಂದಿಗೂ.

212
00:11:36,220 --> 00:11:38,310
ಆದ್ದರಿಂದ, ಈ
ನಿರ್ದಿಷ್ಟ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್

213
00:11:38,310 --> 00:11:43,040
ವಾಸ್ತವವಾಗಿ ವಿರಾಮ ಎಂದಿಗೂ
ಕಾರ್ಯಕ್ರಮದ.

214
00:11:43,040 --> 00:11:48,020
>> ಇದರಿಂದ ನಾನು ಸರಿಯಾಗಿ ರಚಿಸಲು ಎಂದು ತಿಳಿಸಿ
ಕೋಡ್ ಕೆಲವು ಸಾಲಿನ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್

215
00:11:48,020 --> 00:11:50,340
ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

216
00:11:50,340 --> 00:11:53,470
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ
ಮುಖ್ಯ ಕಾರ್ಯ ಮೊದಲ ಸಾಲಿನ.

217
00:11:53,470 --> 00:11:56,630
ಆದ್ದರಿಂದ ಇದು ನಿಸ್ಸಂಶಯವಾಗಿ ಇರುತ್ತದೆ
ಎಂದು, ನಾನು ಮರಣದಂಡನೆ ಆರಂಭ ಬೇಗ,

218
00:11:56,630 --> 00:11:58,580
ಮೊದಲ ಸಾಲನ್ನು ಮುಟ್ಟಲು ಸಾಧ್ಯ.

219
00:11:58,580 --> 00:12:00,230
GDB ಮರಣದಂಡನೆ ವಿರಾಮ.

220
00:12:00,230 --> 00:12:04,100
ತದನಂತರ, ನಾನು ಸಾಧ್ಯವಾಗುತ್ತದೆ
ದೋಷನಿವಾರಕದ ಸಂವಹನ.

221
00:12:04,100 --> 00:12:08,480
>> ನೀವು ಅನೇಕ ಸಾಲುಗಳ ಹೊಂದಿಸಬಹುದು
ನೀವು ಬಯಸಿದಲ್ಲಿ, ಬ್ರೇಕ್ಪಾಯಿಂಟ್.

222
00:12:08,480 --> 00:12:11,365
ನಾವು ಒಂದು ಸಾಲಿನ ರಚಿಸಬಹುದು
ಇಲ್ಲಿ ಕೋಡ್ ಈ ವಿಭಾಗದಲ್ಲಿ

223
00:12:11,365 --> 00:12:12,490
ಎಂದು ತಲುಪಬಹುದು ಎಂದಿಗೂ.

224
00:12:12,490 --> 00:12:14,744
ಮತ್ತು ನಾವು ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಒಂದು ಹೊಂದಿಸಬಹುದು.

225
00:12:14,744 --> 00:12:16,660
ಕಾರಣ ನಾವು ಎಂದು
ನಾವು ಮಾಡುತ್ತೇವೆ ಈ ಮಾಡಲು ಬಯಸುವ

226
00:12:16,660 --> 00:12:19,119
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಹೋಗಿ
ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ವಿವರ.

227
00:12:19,119 --> 00:12:21,660
ಆದ್ದರಿಂದ ಈಗ, ನನಗೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು
ಈ ಹೆಚ್ಚುವರಿ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್

228
00:12:21,660 --> 00:12:24,940
ನಾವು ಏನಾಗುತ್ತದೆ ನೋಡಿದರೆ ಇದರಿಂದ
ನಾನು ಒಂದೇ ಬ್ರೇಕ್ ಮಾಡಿಕೊಂಡು

229
00:12:24,940 --> 00:12:27,650
ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಪಾಯಿಂಟ್.

230
00:12:27,650 --> 00:12:29,410
ನಾನು ಮಾಡಿದ ಕೆಲವು
ಈ ಪ್ರೋಗ್ರಾಂ ಬದಲಾವಣೆಗಳನ್ನು.

231
00:12:29,410 --> 00:12:30,750
ಹಾಗಾಗಿ ಅದನ್ನು ಉಳಿಸಲು ಅಗತ್ಯವಿದೆ.

232
00:12:30,750 --> 00:12:34,490
ನಾನು ಡಿಬಗ್ ಕ್ಲಿಕ್ ಮಾಡಿ ನಾನು ಇದರಿಂದ
ಸಂಕಲನ ಆರಂಭಿಸಲು ತದನಂತರ

233
00:12:34,490 --> 00:12:36,880
ದೋಷನಿವಾರಕದ ಮರಣದಂಡನೆ.

234
00:12:36,880 --> 00:12:40,632
>> ನಾವು ನೋಡುತ್ತಾರೆ, ಆ ಕ್ಷಣಗಳು, ನಂತರ
ನಾವು ಬ್ರೇಕ್ ಆಯ್ಕೆ ಮಾಡಿರುವ ಲೈನ್

235
00:12:40,632 --> 00:12:43,360
ಪಾಯಿಂಟ್ ಹಳದಿ ರಲ್ಲಿ ಹೈಲೈಟ್.

236
00:12:43,360 --> 00:12:47,440
ನಾವು ಗಮನಿಸಿ ಮಾಡಬಹುದು
ಡಿಬಗ್ ಫಲಕದಲ್ಲಿ ಮೇಲಿನ ಬಲ

237
00:12:47,440 --> 00:12:50,940
ವಿರಾಮ ಐಕಾನ್ ಮಾಡಲಾಗಿದೆ ಎಂದು
ಸ್ವಲ್ಪ ಆಟ ಐಕಾನ್ ಆಗಿ.

238
00:12:50,940 --> 00:12:54,710
ಈ ನಾವು ವಿರಾಮ ಎಂದು ಅರ್ಥ
ಮರಣದಂಡನೆ, ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ.

239
00:12:54,710 --> 00:12:57,840
ಮತ್ತು ಆಟದ ಗುಂಡಿಯನ್ನು ಎಂದು ಹೊಡೆಯುವ
ನಮಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮರಳಿ ಅವಕಾಶ

240
00:12:57,840 --> 00:13:00,000
ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ.

241
00:13:00,000 --> 00:13:03,240
>> ಇತರ ಒಂದೆರಡು ಇಲ್ಲ ಎಂದು ಗಮನಿಸಿ
ಈ ಡಿಬಗ್ ಫಲಕದಲ್ಲಿ ಲಭ್ಯವಿದೆ ಗುಂಡಿಗಳು

242
00:13:03,240 --> 00:13:04,220
ಜೊತೆಗೆ.

243
00:13:04,220 --> 00:13:09,470
ನನಗೆ ಅನುಮತಿಸುವ, ಮುಂದಕ್ಕೆ ಹೋಗು
ಕೋಡ್ ಒಂದು ಸಾಲಿನ ಕಾರ್ಯಗತಗೊಳಿಸಲು

244
00:13:09,470 --> 00:13:14,030
ಮತ್ತು ಆ ಸಾಲಿಗೆ ಪ್ರತಿ ಹಂತಕ್ಕೆ
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮುಂದಿನ ಒಂದು, ಇದು,

245
00:13:14,030 --> 00:13:17,060
printf ಎಂದು ಅರ್ಥ
ಹೇಳಿಕೆಯನ್ನು ಕಾರ್ಯರೂಪಕ್ಕೆ.

246
00:13:17,060 --> 00:13:22,310
ಮತ್ತು ನಂತರ ವಿರಾಮ
ಆದ್ದರಿಂದ ಸಾಲಿನಲ್ಲಿ 13 ಮರಣದಂಡನೆ,.

247
00:13:22,310 --> 00:13:25,090
>> ಮತ್ತು ಒಂದು ಹೆಜ್ಜೆ ಇತ್ತು
ಕಾರ್ಯ ಒಳಗೆ ಇದು

248
00:13:25,090 --> 00:13:28,950
ನಾನು ಇತರ ರಚಿಸಿದ ಉಪಯುಕ್ತವಾಗಿದೆ
ಬೇರೆಡೆ ಮೂಲ ಕೋಡ್ ಕಾರ್ಯಗಳನ್ನು.

249
00:13:28,950 --> 00:13:31,420
ನಾನು ಒಳಗೆ ಹೆಜ್ಜೆಯಿಟ್ಟು ಬಯಸುವ
ಆ ಕಾರ್ಯಗಳನ್ನು ಬದಲಿಗೆ

250
00:13:31,420 --> 00:13:33,050
ಇಡೀ ಕಾರ್ಯ ನಿರ್ವಹಿಸಲು.

251
00:13:33,050 --> 00:13:37,279
ಆದರೆ ನಾವು ಹಂತದಲ್ಲೂ ಹೆಚ್ಚು ನೋಡಲು ಮಾಡುತ್ತೇವೆ
ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಕಾರ್ಯ.

252
00:13:37,279 --> 00:13:40,320
ಈಗ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಗಮನಕ್ಕೆ
ವಾಸ್ತವವಾಗಿ ಈ ಡಿಬಗ್ ಫಲಕದೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ.

253
00:13:40,320 --> 00:13:44,110
>> ಈ ಫಲಕ ಎಂಬ
ಇದು ನಮಗೆ ತೋರಿಸುತ್ತದೆ, ಸ್ಟಾಕ್ ಕರೆ

254
00:13:44,110 --> 00:13:45,300
ನಿಖರವಾಗಿ ನಾವು ಅಲ್ಲಿ.

255
00:13:45,300 --> 00:13:48,550
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಳಗೆ
ಮುಖ್ಯ ಕಾರ್ಯ.

256
00:13:48,550 --> 00:13:50,880
ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ count.c ಕರೆಯಲಾಗುತ್ತದೆ.

257
00:13:50,880 --> 00:13:53,820
ಮತ್ತು ನಾವು ಎಂದು ಸಂಭವಿಸಿ
ಸಾಲು 13, ಕಾಲಮ್ ಒಂದು, ಇದು

258
00:13:53,820 --> 00:13:58,950
ಏನು ಹೈಲೈಟ್ ಪ್ರದೇಶದಲ್ಲಿ ನಿಖರವಾಗಿ
ಮೂಲ ಕೋಡ್ ಜೊತೆಗೆ, ಸೂಚಿಸುತ್ತದೆ.

259
00:13:58,950 --> 00:14:02,435
>> ಈಗ ಇದು ತೋರಿಸುತ್ತದೆ ಗಮನಕ್ಕೆ
ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ವಿಭಾಗ ಅಡಿಯಲ್ಲಿ

260
00:14:02,435 --> 00:14:06,710
ಅಸ್ಥಿರ ಎಲ್ಲಾ
ಈ ಕಾರ್ಯ ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

261
00:14:06,710 --> 00:14:08,930
ಇದು ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿರುತ್ತದೆ
ಅಸ್ಥಿರ ಎಲ್ಲಾ

262
00:14:08,930 --> 00:14:12,580
ಈ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಕಾಣಿಸುತ್ತದೆ
ಒಂದು ಕಾರ್ಯದ ಒಳಗೆ ವಿಭಾಗ

263
00:14:12,580 --> 00:14:14,380
ಅವರು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮೊದಲು.

264
00:14:14,380 --> 00:14:19,160
ನಾವು ವೇರಿಯಬಲ್ ಎಂದು ಇಲ್ಲಿ ನೋಡಬಹುದು
ಎಂಬ NUM, 0 ಒಂದು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ,

265
00:14:19,160 --> 00:14:21,280
ಮತ್ತು ಕೌಟುಂಬಿಕತೆ ಇಂಟ್ ಹೊಂದಿದೆ.

266
00:14:21,280 --> 00:14:24,110
>> ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಆರಂಭಿಸಲು ಮೊದಲು
ಈ ವ್ಯತ್ಯಾಸಗಳ ಎಲ್ಲಾ,

267
00:14:24,110 --> 00:14:26,685
ನಾವು ಅಗತ್ಯವಾಗಿ ಇಲ್ಲ
0 ಒಂದು ಮೌಲ್ಯವನ್ನು ನೋಡಲು ಭರವಸೆ.

268
00:14:26,685 --> 00:14:29,200
ಮತ್ತು ಇತರ ಮರಣದಂಡನೆ ಅವಲಂಬಿಸಿ
ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆ ಎಂದು

269
00:14:29,200 --> 00:14:32,020
ನಿಮ್ಮ ಮೆಮೊರಿ ಮಾಡಿದಾಗ ರಾಜ್ಯದ
ನೀವು ವಾಸ್ತವವಾಗಿ ಈ ಪ್ರೋಗ್ರಾಂ,

270
00:14:32,020 --> 00:14:34,605
ನೀವು ಎಂದು ಅನಿಸಬಹುದು
0 ಮೌಲ್ಯಗಳನ್ನು ಕಾಣುವುದಿಲ್ಲ

271
00:14:34,605 --> 00:14:36,550
ಮತ್ತು, ಅವು ಕೆಲವು ಇತರ ಅಸಾಮಾನ್ಯ ಸಂಖ್ಯೆಗಳು.

272
00:14:36,550 --> 00:14:38,390
>> ಆದರೆ ಆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

273
00:14:38,390 --> 00:14:44,610
ಇದು ತನಕ ಸೂಕ್ತ ಎಂದು ಹಿಂದಿರುಗಬಹುದೆಂದು
ನೀವು ನಿಜವಾಗಿಯೂ ಮೌಲ್ಯವನ್ನು ಆರಂಭಿಸಲು.

274
00:14:44,610 --> 00:14:49,630
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೋಡಬಹುದು
ನಾನು ಕೆಲವು ಉತ್ಪನ್ನಗಳೆಂದರೆ ನಿರ್ವಹಿಸಿದ್ದಾರೆ.

275
00:14:49,630 --> 00:14:52,131
ನಾನು, ಇದೀಗ, ಮರಣದಂಡನೆ ನಿಲ್ಲಿಸಲಾಗಿದೆ ಬಾಗುತ್ತೇನೆ.

276
00:14:52,131 --> 00:14:53,880
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಯಾವ
ನಾನು ಮಾಡಲು ಬಯಸುವ

277
00:14:53,880 --> 00:14:58,060
ಈಗ ಈ ರೇಖೆಯ ಮೇಲೆ ಹಂತಕ್ಕೆ ಆಗಿದೆ
ಕೋಡ್ ಆಫ್ ಆದ್ದರಿಂದ ನಾನು ಆ

278
00:14:58,060 --> 00:15:04,390
ಎಂದು ಇಂಟ್ ಬಳಕೆದಾರ ಪ್ರಶ್ನಿಸಿ ಎಂದು
ನಾವು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ.

279
00:15:04,390 --> 00:15:07,060
>> ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಆಗ
ನಾನು ಸೂಚನೆ ಮೇಲೆ ಹೆಜ್ಜೆ ಹಿಟ್

280
00:15:07,060 --> 00:15:11,940
ಬದಲಿಗೆ ವಿರಾಮ ಅಥವಾ ಪುನರಾರಂಭಿಸು
ಬಟನ್ ಈ ವಿರಾಮ ಬಟನ್ ಬದಲಾಗಿದೆ

281
00:15:11,940 --> 00:15:14,022
ಈ ಕೋಡ್ ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಏಕೆಂದರೆ.

282
00:15:14,022 --> 00:15:15,730
ಏನಾಗುತ್ತಿದೆ
ಇದೀಗ ಇದು ಎಂದು

283
00:15:15,730 --> 00:15:21,630
ಇನ್ಪುಟ್ ನಮಗೆ ಕೆಲವು ಮಾಹಿತಿ ಕಾಯುವ
ನಾವು ನಮ್ಮ ಔಟ್ಪುಟ್ ಪಠ್ಯ ಮೂಲಕ ನೋಡಬಹುದು

284
00:15:21,630 --> 00:15:23,600
ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ.

285
00:15:23,600 --> 00:15:25,787
>> ಆದ್ದರಿಂದ ಇದೀಗ, ಈ
ವಾಸ್ತವವಾಗಿ ನಿಲ್ಲಿಸಲಾಗಿದೆ ಅಲ್ಲ,

286
00:15:25,787 --> 00:15:28,620
ಇದು ಸಹ, ರೀತಿಯ, ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ
ಏನೂ ನಡೆಯುತ್ತಿದೆ ಏಕೆಂದರೆ ಎಂದು.

287
00:15:28,620 --> 00:15:32,360
ಆದರೆ ಇದು ಕೇವಲ ಹಾಗೆ ನಡೆಯುತ್ತದೆ ಆ
ಸಾಲು 13 ರಂದು ನನ್ನ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ,

288
00:15:32,360 --> 00:15:34,210
ನಾನು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಕಾಯುತ್ತಿದೆ ಬಾಗುತ್ತೇನೆ.

289
00:15:34,210 --> 00:15:39,130
ಮತ್ತು ಆದ್ದರಿಂದ GDB ಪರೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಇದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿದೆ.

290
00:15:39,130 --> 00:15:43,370
>> ನಾನು ಕೆಲವು ನಮೂದಿಸುವ ಈಗ ಮುಂದಿನ ಬಾರಿ
ಇನ್ಪುಟ್ ಆದ್ದರಿಂದ ನಾನು ಸಂಖ್ಯೆ 5 ನಮೂದಿಸಿ

291
00:15:43,370 --> 00:15:46,140
ನಾವು ನೋಡಿರುವ
ಹಿಟ್ ರಿಟರ್ನ್ past--, ಮತ್ತು ನಾವು

292
00:15:46,140 --> 00:15:51,430
ಎಂದು, ತಕ್ಷಣ, GDB ನಡೆಸುತ್ತಿದ್ದಳು ಗಮನಕ್ಕೆ
ಮತ್ತು, ಮತ್ತೆ, ಮುಂದಿನ ಸಾಲಿನ ತೋರಿಸುತ್ತದೆ.

293
00:15:51,430 --> 00:15:55,320
ಆದರೆ, ಈಗ ಗಮನಕ್ಕೆ
ನಮ್ಮ ಮೇಲಿಂಗ್ ನಮೂದಿಸುವುದರ ಪರಿಣಾಮವಾಗಿ,

294
00:15:55,320 --> 00:15:58,930
ನಾವು ಒಳಗೆ ಮೌಲ್ಯವನ್ನು ಅಪ್ಡೇಟ್ಗೊಳಿಸಲಾಗಿದೆ
ನಮ್ಮ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು, ಯಾವ

295
00:15:58,930 --> 00:16:05,560
ನಿಖರವಾಗಿ ತಿಳಿಯಲು ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ
ಏನು ಎಂದು ನೆನೆಪು.

296
00:16:05,560 --> 00:16:10,650
>> ಈಗ ನಾನು ಈ ಪ್ರೋಗ್ರಾಂ ಮುಂದುವರೆಯಲು ಅನುಮತಿಸಬಹುದು
ಅದರ ನಿರ್ವಹಣೆ ಕೊನೆಯವರೆಗೆ ಆಡುವ

297
00:16:10,650 --> 00:16:12,570
ಪುನರಾರಂಭಿಸು ಹೊಡೆದಿದ್ದರು.

298
00:16:12,570 --> 00:16:16,410
ನಾವು ಬೇಗನೆ ನೋಡಬಹುದು
ಕಾರ್ಯಕ್ರಮದ ಮುಕ್ತಾಯದ ಪಾಲಿಸಲು ಮಾಡುತ್ತದೆ

299
00:16:16,410 --> 00:16:19,790
ಅದೇ ಔಟ್ಪುಟ್ ಜೊತೆ ನಾವು
ಮೊದಲು, ದೋಷಸೂಚಕವು ಮುಚ್ಚುವುದು

300
00:16:19,790 --> 00:16:23,170
ಮತ್ತು ಈಗ ಈ ಪ್ರೋಗ್ರಾಂ
ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಗಿತಗೊಂಡಿದೆ.

301
00:16:23,170 --> 00:16:25,320
>> ನಾನು ತೋರಿಸಲು ಮಾತ್ರ ಆ
ನೋಡಿದ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಏನು

302
00:16:25,320 --> 00:16:27,280
ನಾವು ವಾಸ್ತವವಾಗಿ ಪುನರಾರಂಭಿಸು ಹೊಡೆದಾಗ ನಡೆಯುತ್ತದೆ.

303
00:16:27,280 --> 00:16:30,640
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಹೋಗುವ
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಹಿಂತಿರುಗಿ ಬಯಸುವ

304
00:16:30,640 --> 00:16:33,820
ನಾವು ಡಿಬಗ್ ಪ್ರಯತ್ನಿಸಿ ಇದರಿಂದ
ನಿಖರವಾಗಿ ಏನು ನಡೆಯುತ್ತಿದೆ.

305
00:16:33,820 --> 00:16:37,980
ನಾನು ದೋಷಸೂಚಕವು ಬಳಸಿಕೊಂಡು ನಾನು ಈಗ, ನಾನು ಒಂದು
ಈ ಡಿಬಗ್ printf ಹೇಳಿಕೆಗಳನ್ನು ಅಗತ್ಯವಿಲ್ಲ.

306
00:16:37,980 --> 00:16:43,860
>> ನಾನು ಮಾಡುತ್ತಾರೆ ಹಾಗಾಗಿ ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ
ಈಗ ಕೇವಲ ನಮ್ಮ ಸರಳವಾದ ಕೋಡ್ ಹಿಂತಿರುಗಿ

307
00:16:43,860 --> 00:16:45,950
ನಾವು ಒಂದು ಕ್ಷಣ ಹಿಂದೆ ಎಂದು.

308
00:16:45,950 --> 00:16:48,790
ಈಗ ನಾನು ಉಳಿಸಿದಾಗ
ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಿ,

309
00:16:48,790 --> 00:16:53,700
ಇದು, ಮತ್ತೆ, ಆರಂಭಿಕ ಹೋಗುತ್ತದೆ
ನಾನು ಸಾಲು 11 ರಂದು ಎಂದು ಪಾಯಿಂಟ್ ಬ್ರೇಕ್.

310
00:16:53,700 --> 00:16:57,700
ನಾನು ಪರೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ
ನನ್ನ ಅಸ್ಥಿರ ನಾನು ಬಯಸುವ ಎಂದು.

311
00:16:57,700 --> 00:17:00,695
>> ಇದು ಕೇವಲ ಆದ್ದರಿಂದ ಈ ಅದು ಸಂಭವಿಸಿದಲ್ಲಿ
ಭಾಗ, ಕುತೂಹಲಕಾರಿ ಅಲ್ಲ

312
00:17:00,695 --> 00:17:04,364
ನಾನು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ತಿಳಿದಿದೆ
ಈ ಹೇಳಿಕೆಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

313
00:17:04,364 --> 00:17:05,280
ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ.

314
00:17:05,280 --> 00:17:08,099
ತದನಂತರ, ನಾನು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ತಿಳಿದಿದೆ
ಆ ಪೂರ್ಣಾಂಕ ಬಳಕೆದಾರ ಕೇಳಲು.

315
00:17:08,099 --> 00:17:13,329
ಆದ್ದರಿಂದ ಬಹುಶಃ, ನಾನು ವಾಸ್ತವವಾಗಿ ಸರಿಸಲು ಬಯಸುವ ನನ್ನ
ಕೆಳಗೆ ಸ್ವಲ್ಪ ಮುಂದೆ ಪಾಯಿಂಟ್ ಬ್ರೇಕ್.

316
00:17:13,329 --> 00:17:16,710
>> ನೀವು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ತೆಗೆದುಹಾಕಬಹುದು
ನೇರವಾಗಿ, ಮತ್ತೆ, ಕ್ಲಿಕ್ಕಿಸಿ

317
00:17:16,710 --> 00:17:18,460
ಸಾಲನ್ನು ಸಂಖ್ಯೆಯ ಎಡಕ್ಕೆ.

318
00:17:18,460 --> 00:17:22,200
ಕೆಂಪು ಬಿಂದುವನ್ನು ಸೂಚಿಸುತ್ತದೆ ನಾಶವಾಗುತ್ತವೆ
ಆ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಈಗ ಹೋದ.

319
00:17:22,200 --> 00:17:24,780
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ,
ಮರಣದಂಡನೆ ನಿಲ್ಲಿಸಲಾಗಿದೆ.

320
00:17:24,780 --> 00:17:27,770
ಮತ್ತು ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಹಿಂದಿರುಗಬಹುದೆಂದು
ಆ ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಗೆ ಪುನರಾರಂಭಿಸಿ.

321
00:17:27,770 --> 00:17:30,210
ಆದರೆ ನಾನು ವಿರಾಮ ಹೊಂದಿಸಬಹುದು
ಸ್ವಲ್ಪ ನಂತರ ಸೂಚಿಸುತ್ತಾರೆ.

322
00:17:30,210 --> 00:17:33,880
>> ಈಗ ನಾನು ಮರಳಿ ನನ್ನ
ಕೋಡ್, ಇದನ್ನು ಮುಂದುವರಿಸಿ ಮತ್ತು ತಿಳಿಸುವರು

323
00:17:33,880 --> 00:17:36,190
ಆ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಪಾಯಿಂಟ್.

324
00:17:36,190 --> 00:17:37,374
ಮತ್ತೆ, ನಾನು ಪುನರಾರಂಭಿಸು ಹಿಟ್.

325
00:17:37,374 --> 00:17:39,040
ಏನು ನಡೆಯುತ್ತಿದೆ ಹಾಗೆ ಕಾಣುವುದಿಲ್ಲ.

326
00:17:39,040 --> 00:17:41,450
ಆದರೆ ನನ್ನ ಕಾರಣ ಇಲ್ಲಿದೆ
ಕೋಡ್ ಇನ್ಪುಟ್ ಕಾಯುತ್ತಿದೆ.

327
00:17:41,450 --> 00:17:47,900
ನಾನು ಹಲವಾರು 5 ನಮೂದಿಸಿ ನಮೂದಿಸಿ ಹಿಟ್, ಮತ್ತು
ಈಗ ಮುಂದಿನ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಹಿಟ್ ಆಗುತ್ತದೆ.

328
00:17:47,900 --> 00:17:50,570
>> ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ
ಕೋಡ್ ಆಫ್ ಲೈನ್

329
00:17:50,570 --> 00:17:53,820
ಎಂದು, ಮೊದಲು, ನಾವು ಗೊತ್ತಿತ್ತು
ದೋಷಯುಕ್ತ ಎಂದು ಸಂಭವಿಸಿದ.

330
00:17:53,820 --> 00:17:57,590
ಆದ್ದರಿಂದ ಏನಾಗುತ್ತದೆ ಮೌಲ್ಯಮಾಪನ ಅವಕಾಶ
ಸಮಯದಲ್ಲಿ ಈ ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ.

331
00:17:57,590 --> 00:18:02,620
ಒಂದು ಸಾಲಿನ ಹೈಲೈಟ್ ಮಾಡಿದಾಗ, ಈ
ಲೈನ್ ಇನ್ನೂ ಕಾರ್ಯರೂಪಕ್ಕೆ ಮಾಡಿಲ್ಲ.

332
00:18:02,620 --> 00:18:06,490
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೋಡಬಹುದು
ನಾನು ಸಂಖ್ಯೆಯ ಹೊಂದಿರುವ ಇದು

333
00:18:06,490 --> 00:18:11,610
ನಾನು ಎಂಬ ಪೂರ್ಣಾಂಕ ಹೊಂದಿವೆ
ಈ ಕೆಳಗಿನ 5 ಹೊಂದಿರುವ ಸಂ.

334
00:18:11,610 --> 00:18:15,090
ನಾನು ಪ್ರದರ್ಶನ ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ
ಎಂದು ಕೆಲವು ಗಣಿತ.

335
00:18:15,090 --> 00:18:20,130
>> ನಾನು ಮೇಲೆ ಹೆಜ್ಜೆ ವೇಳೆ, ನಾವು
NUM ಆ ಮೌಲ್ಯವನ್ನು ಗಮನಕ್ಕೆ

336
00:18:20,130 --> 00:18:23,780
ಅನುಗುಣವಾಗಿ ಬದಲಾಗಿದೆ
ನಾವು ವಾಸ್ತವವಾಗಿ ಮಾಡಿದ ಅಂಕಗಣಿತದ.

337
00:18:23,780 --> 00:18:26,810
ಮತ್ತು ಈಗ ನಾವು ಆ
ಒಳಗೆ ಲೂಪ್ ಈ

338
00:18:26,810 --> 00:18:29,090
ಅಥವಾ ಈಗ ಲೂಪ್
ಸ್ವತಃ ಹೈಲೈಟ್,

339
00:18:29,090 --> 00:18:32,450
ನಾವು ಹೊಸ ಎಂದು ನೋಡಿ
ವೇರಿಯಬಲ್ ಎಂದು ನಾನು ಎಂದು

340
00:18:32,450 --> 00:18:35,370
ಲೂಪ್ ಎಂದು ಬಳಸಲಾಗುತ್ತದೆ ಏರಲಿದೆ.

341
00:18:35,370 --> 00:18:38,230
>> ಈಗ ನಾನು ಮೊದಲು ನೆನಪು
ಕೆಲವೊಮ್ಮೆ ನೀವು ಎಂಬುದನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ

342
00:18:38,230 --> 00:18:43,470
ಕ್ರೇಜಿ ರೀತಿಯ ನೋಡಲು ಹೋಗುವ
ಎಂದು ಮೊದಲು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು

343
00:18:43,470 --> 00:18:45,530
ಅಥವಾ ವ್ಯತ್ಯಯ
ವಾಸ್ತವವಾಗಿ ಆರಂಭಿಸಲಾಗಿಲ್ಲ.

344
00:18:45,530 --> 00:18:49,040
ನಾವು ನಿಖರವಾಗಿ ನೋಡಬಹುದು
ಇಲ್ಲಿ ಈ ವೇರಿಯಬಲ್

345
00:18:49,040 --> 00:18:51,345
ಅಲ್ಲ, ಇದು ನಾನು ಎಂದು
ಇನ್ನೂ ಇನ್ನೂ ಆರಂಭಗೊಂಡಿಲ್ಲ

346
00:18:51,345 --> 00:18:53,560
ಹೈಲೈಟ್ ಸಮಯದಲ್ಲಿ.

347
00:18:53,560 --> 00:18:57,070
ಆದರೆ ನಾವು ಕೆಲವು ಹೊಂದಿದೆ ನೋಡಬಹುದು
ನಾವು ವಾಸ್ತವವಾಗಿ ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು.

348
00:18:57,070 --> 00:18:57,620
>> ಒಕೆ.

349
00:18:57,620 --> 00:18:59,661
ಅದರ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ
ನಾವು ವಾಸ್ತವವಾಗಿ ಏಕೆಂದರೆ

350
00:18:59,661 --> 00:19:04,970
ನಾನು ರವರೆಗೆ ಎಂದು ಆರಂಭಿಸಲಾಗಿಲ್ಲ
ಈ ಸಾಲಿನ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಹೆಜ್ಜೆ

351
00:19:04,970 --> 00:19:08,560
ನಾನು ಮೌಲ್ಯವನ್ನು 1 ಆರಂಭಗೊಂಡಿದೆ.

352
00:19:08,560 --> 00:19:11,400
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಎಂದು ನೋಡಲು
ಸಂದರ್ಭದಲ್ಲಿ, ಅವರ ಮೇಲೆ ಹೆಜ್ಜೆ ಅವಕಾಶ.

353
00:19:11,400 --> 00:19:14,420
ನಾವು ಈಗ ನೋಡಬಹುದು
ಲೈನ್ ಮರಣದಂಡನೆ ಮಾಡಲಾಗಿದೆ.

354
00:19:14,420 --> 00:19:17,000
ನಾವು ಈಗ ಹೈಲೈಟ್ ಮಾಡಲಾಗುತ್ತದೆ
ಈ printf ಸಾಲನ್ನು.

355
00:19:17,000 --> 00:19:22,230
>> ನಾವು ಈಗ ಹೇಗೆ ನಮ್ಮ ಮೌಲ್ಯಗಳನ್ನು ನೋಡಬಹುದು
ನಾನು ಮತ್ತು 3 ಕಾಲಾಂತರದಲ್ಲಿ ಬದಲಾಗಿದೆ.

356
00:19:22,230 --> 00:19:26,450
ಈ ವಾಸ್ತವವಾಗಿ, ಮಾಡಲು ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ,
ಪದೇಪದೇ ಲೈನುಗಳಿಗೆ ಹಂತಕ್ಕೆ ಆಗಿದೆ.

357
00:19:26,450 --> 00:19:30,480
ಮತ್ತು ನೀವು ವಾಸ್ತವವಾಗಿ ಕಾಣಬಹುದು
ನಿಮ್ಮ ಲೂಪ್ ಒಳಗೆ ನಡೆಯುತ್ತದೆ

358
00:19:30,480 --> 00:19:33,660
ಮತ್ತು ಯಾವ ನಡೆಯುತ್ತದೆ
ಒಳಗೆ ಲೂಪ್ ಎಂದು ಅಸ್ಥಿರ

359
00:19:33,660 --> 00:19:39,200
ಕಾರ್ಯಕ್ರಮದ ಗಲ್ಲಿಗೇರಿಸಿದ್ದು
ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಹೆಜ್ಜೆ ಸಂಭವಿಸುತ್ತದೆ.

360
00:19:39,200 --> 00:19:41,110
>> ಈಗ ಈ ಹಂತದಲ್ಲಿ, ನಾನು
ಕೇವಲ ಸಾಕಷ್ಟು ಮೇಲೆ ಕೆಳಗಿಳಿದ

361
00:19:41,110 --> 00:19:44,210
ನಾನು ಈಗ ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ನಾನು.

362
00:19:44,210 --> 00:19:46,980
ನಾನು ಮೇಲೆ ಹೆಜ್ಜೆ ವೇಳೆ, ಇದು
ವಾಸ್ತವವಾಗಿ ಮರಣದಂಡನೆ ನಿಲ್ಲಿಸಲು

363
00:19:46,980 --> 00:19:48,860
ನಾವು ಹಿಂದೆ ನೋಡಿದಂತೆ.

364
00:19:48,860 --> 00:19:52,110
ಆದ್ದರಿಂದ, ನನಗೆ ಮತ್ತೊಮ್ಮೆ, ಈ ಪುನರ್ ಲೆಟ್
ನಾನು ಯಾವುದೋ ಎತ್ತಿ ಎಂದು,

365
00:19:52,110 --> 00:19:53,320
ಜೊತೆಗೆ.

366
00:19:53,320 --> 00:19:55,350
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು
ಈಗ ಮತ್ತೆ ಕೇಳುತ್ತಿದ್ದರು,

367
00:19:55,350 --> 00:19:57,100
ಒಂದು ಸಂಖ್ಯೆಯ ಇದು
ನಾನು ಮತ್ತೆ, ನಮೂದಿಸಿ.

368
00:19:57,100 --> 00:20:00,300
ಆದರೆ ಈ ಬಾರಿ, ನಾನು ಪ್ರವೇಶಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಆದ್ದರಿಂದ ಲೂಪ್

369
00:20:00,300 --> 00:20:02,540
ಹೆಚ್ಚು ಬಾರಿ ತಿರುಗಿ ಕಾಣಿಸುತ್ತದೆ.

370
00:20:02,540 --> 00:20:06,090
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
11 ಈ ಕೆಳಗಿನ ನಮೂದಿಸಿ.

371
00:20:06,090 --> 00:20:08,390
>> ಈಗ ಮತ್ತೆ ನಾನು ಸೆಟ್ ಬಯಸುವ ಏಕೆಂದರೆ
ಸಾಲು 15 ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್,

372
00:20:08,390 --> 00:20:10,490
ಇದು ಸಾಲನ್ನು ಹೈಲೈಟ್ ಹೋಗುವುದಿಲ್ಲ.

373
00:20:10,490 --> 00:20:12,980
ನಾವು ನೋಡಬಹುದು ನಮ್ಮ
ಸಂಖ್ಯೆ 11 ಸರಿಯಾಗಿ ಆಗಿದೆ

374
00:20:12,980 --> 00:20:15,560
ನಮ್ಮ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ನಿರೂಪಿಸಲಾಗಿದೆ.

375
00:20:15,560 --> 00:20:22,460
ನಾವು ಈಗ, ಆ ಮೇಲೆ ಮಾಡಬಹುದು ಮೆಟ್ಟಿಲು
ನಮ್ಮ ಮೌಲ್ಯ ನ ನಾನು ಏನಾಗುತ್ತದೆ ವೀಕ್ಷಿಸಲು

376
00:20:22,460 --> 00:20:25,680
ನಾವು ಲೂಪ್ ಈ ಒಳಗೆ ಮುಂದುವರೆಯಲು.

377
00:20:25,680 --> 00:20:31,960
ಇದು ಪ್ರತಿ ಬಾರಿ ನಾವು ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು
ಲೂಪ್ ಎಂದು ತಲುಪಿರುವುದು.

378
00:20:31,960 --> 00:20:35,110
>> ವಸ್ತುಗಳ ಒಂದು ಈಗ ಇರಬಹುದು
ನಿರ್ವಹಣೆಯ ಅವಧಿಯಲ್ಲಿ ಮಾಡಲು ಉಪಯುಕ್ತ

379
00:20:35,110 --> 00:20:40,490
ಈ ಕಾರ್ಯಕ್ರಮದ ವಾಸ್ತವವಾಗಿ ನನಗೆ ಆಗಿದೆ
ನೋಡಲು ಅಸ್ಥಿರ midstream ಬದಲಾಯಿಸಲು

380
00:20:40,490 --> 00:20:42,450
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಸಂಭವಿಸುತ್ತದೆ.

381
00:20:42,450 --> 00:20:46,540
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ವಾಸ್ತವವಾಗಿ ಮಾಡಬಹುದು
ಡಬಲ್ ಮೌಲ್ಯವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.

382
00:20:46,540 --> 00:20:48,040
ಇದು ಪಠ್ಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಆಗುತ್ತದೆ ಗಮನಿಸಿ.

383
00:20:48,040 --> 00:20:50,280
>> ಈಗ ನಾನು ವಿವಿಧ ನಮೂದಿಸಬಹುದು
ಒಟ್ಟಾರೆಯಾಗಿ ಮೌಲ್ಯ

384
00:20:50,280 --> 00:20:55,700
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ವರ್ತಿಸುತ್ತದೆ ಹೇಗೆ ನೋಡಿ
ನಾನು ವ್ಯತ್ಯಯ ಬದಲಾಯಿಸಿದ್ದರೆ ಮಾಡಿದಾಗ.

385
00:20:55,700 --> 00:20:59,560
ಈಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವೇರಿಯಬಲ್
ನಾನು ಈಗ ಮೌಲ್ಯ 10 ಹೊಂದಿದೆ.

386
00:20:59,560 --> 00:21:02,810
ಆದರೆ ಪ್ರೋಗ್ರಾಂ ಇನ್ನೂ
ಮರಣದಂಡನೆಯಲ್ಲಿ ನಿಲ್ಲಿಸಲಾಗಿದೆ.

387
00:21:02,810 --> 00:21:07,610
ನಾನು ಮೇಲೆ ಹೆಜ್ಜೆ, ನಾನು ನೋಡಿ
ನಾನು 10 ನಮೂದಿಸಿರುವ ಮೌಲ್ಯವನ್ನು ನಾನು,

388
00:21:07,610 --> 00:21:12,170
, NUM ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚು ದೊಡ್ಡದಾಗಿರುತ್ತದೆ
ಇದು ತಕ್ಷಣ ಲೂಪ್ ಕಾರಣವಾಗುತ್ತದೆ

389
00:21:12,170 --> 00:21:14,240
ಪಾಲಿಸಲು ನಿಲ್ಲಿಸಲು.

390
00:21:14,240 --> 00:21:16,210
>> ಈಗ ಮಾತ್ರ ಅಲ್ಲ
ಕಾರಣವೇನೆಂದರೆ ಎಂದು

391
00:21:16,210 --> 00:21:19,450
ಸ್ಥಳದಲ್ಲಿ ವೇರಿಯಬಲ್ ಮಾರ್ಪಡಿಸಲು ಬಯಸುವ.

392
00:21:19,450 --> 00:21:22,210
ನೀವು ನಿಜವಾಗಿಯೂ ಬಯಸಬಹುದು
ಅದು ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ

393
00:21:22,210 --> 00:21:24,590
ನೀವು ಮುಂದುವರಿಸಬಹುದು
ಲೂಪ್ ಮರಣದಂಡನೆ

394
00:21:24,590 --> 00:21:27,370
ಅಥವಾ ಎಷ್ಟು ನೀವು ಮಾರ್ಪಡಿಸಬಹುದು
ಇದು ಮೊದಲು ಕೆಲವು ಮೌಲ್ಯವನ್ನು

395
00:21:27,370 --> 00:21:32,630
ಅಂಕಗಣಿತದ ಕೆಲವು ನಿರ್ದಿಷ್ಟ ತಲುಪುತ್ತದೆ
ನೀವು ನಿರ್ವಹಿಸಲು ಸಂಭವವಿರುವ.

396
00:21:32,630 --> 00:21:36,210
>> ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಬದಲಿಸುವುದು
ಪ್ರೋಗ್ರಾಂ ನಾನು ಮೌಲ್ಯವನ್ನು, ಪಾಲಿಸಲು ಮಾಡಲಾಯಿತು

397
00:21:36,210 --> 00:21:39,540
ಇದು ಲೂಪ್ ತ್ಯಜಿಸಿ ಮಾಡಿತು
ಅಕಾಲಿಕವಾಗಿ ನಾನು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಎಲ್ಲಾ, ಏಕೆಂದರೆ

398
00:21:39,540 --> 00:21:42,770
ಮೌಲ್ಯ ಹೆಚ್ಚಾಗಿದೆ ಎಂದು ಸಂಭವಿಸಿದ
NUM ಲೂಪ್ ಎಂದು ಅಂದರೆ

399
00:21:42,770 --> 00:21:45,410
ಇನ್ನು ಮುಂದೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ.

400
00:21:45,410 --> 00:21:48,780
ಇದಲ್ಲದೆ, ಎಂದು ಸಂಭವಿಸಿದ
ನಾವು ನಾನು ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿತು ಸಂದರ್ಭದಲ್ಲಿ

401
00:21:48,780 --> 00:21:53,270
ಸಾಲು 17 ಹೈಲೈಟ್ ಮಾಡಿದಾಗ,
ಸಮಯದಲ್ಲಿ ಕೇಂದ್ರವಾಗಿತ್ತು

402
00:21:53,270 --> 00:21:56,280
ಲೂಪ್ ಮರಣದಂಡನೆಗೆ
ವಾಸ್ತವವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಯಿತು.

403
00:21:56,280 --> 00:22:00,210
>> ನಾನು ಮೌಲ್ಯದ ಬದಲಾಯಿತು ವೇಳೆ
ನಾನು ಬೇರೆ ಸಾಲಿನಲ್ಲಿ, 19 ಸೇ

404
00:22:00,210 --> 00:22:03,360
ನಾವು ವಿವಿಧ ನೋಡಿದ್ದೇನೆ ಎಂದು
ನಡವಳಿಕೆಯಿಂದಾಗಿ 19 ಏಕೆಂದರೆ

405
00:22:03,360 --> 00:22:08,310
ಲೂಪ್ ಮೊದಲು ಮರಣದಂಡನೆ
ಪರಿಸ್ಥಿತಿ ಮರುಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಯಿತು.

406
00:22:08,310 --> 00:22:11,900
ಈಗ ಈ ಹಂತದಲ್ಲಿ, ನಾನು, ಮತ್ತೆ,
ಈ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ.

407
00:22:11,900 --> 00:22:15,707
ಮತ್ತು ನಾನು ಈ ಮುಂದುವರೆಯಲು ಅವಕಾಶ
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಸ್ವಾಭಾವಿಕವಾಗಿ ಬಿಟ್ಟು ಅವಕಾಶ.

408
00:22:15,707 --> 00:22:18,290
ಆದರೆ ವಿಷಯಗಳನ್ನು ಒಂದೆರಡು ಇಲ್ಲ
ತೆಗೆದುಕೊಳ್ಳುವ ಮುಖ್ಯ ಎಂದು

409
00:22:18,290 --> 00:22:19,960
ಈ ನಿರ್ದಿಷ್ಟ ಚರ್ಚೆಯಿಂದ.

410
00:22:19,960 --> 00:22:22,490
ನೀವು ಮೌಲ್ಯಮಾಪನ ಅಗತ್ಯವಿದೆ
ನಿಮ್ಮ ಸ್ವಂತ ಊಹೆಗಳನ್ನು

411
00:22:22,490 --> 00:22:24,710
ಬಗ್ಗೆ ಕೋಡ್ ವರ್ತಿಸುವ ಮಾಡಬೇಕು.

412
00:22:24,710 --> 00:22:28,220
ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನೀವು ಕೆಲವು ತುಣುಕು ಭಾವಿಸುತ್ತೇನೆ
ನಿಮಗೆ ಕೋಡ್ ಕೆಲಸ ನಡೆಯುತ್ತದೆ,

413
00:22:28,220 --> 00:22:30,940
ಹೋಗಲು ಒಂದು ಕೆಂಪು ಧ್ವಜ ಇರಬಹುದು
ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ, ಮತ್ತು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

414
00:22:30,940 --> 00:22:33,470
ನಿಮ್ಮ ಊಹೆ ಎಂದರೆ
ಹೇಗೆ ಕೋಡ್ ಕಾರ್ಯಾಚರಿಸುತ್ತಿದೆ

415
00:22:33,470 --> 00:22:38,290
ಇದು ಎಷ್ಟು ವಾಸ್ತವವಾಗಿ ನಿಜ
ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ವ್ಯಕ್ತಪಡಿಸಿದರು.

416
00:22:38,290 --> 00:22:41,300
>> ಆದರೆ ಪಾಯಿಂಟ್ ಇನ್ನಷ್ಟು ಆಗಿತ್ತು,
ನಾವು ದೋಷಸೂಚಕವು ಬಳಸಿಕೊಂಡು ಮಾಡಿದಾಗ,

417
00:22:41,300 --> 00:22:43,920
ನೀವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಾಕಬಹುದು
ಕೋಡ್ ವಿವಿಧ ಸಾಲುಗಳು

418
00:22:43,920 --> 00:22:48,110
ದೋಷಸೂಚಕವು ಮಾಡುತ್ತದೆ
ಆ ಸಾಲುಗಳನ್ನು ಪ್ರತಿಯೊಂದು ಮರಣದಂಡನೆ ವಿರಾಮ

419
00:22:48,110 --> 00:22:52,210
ಆದ್ದರಿಂದ ನೀವು ಮೌಲ್ಯಮಾಪನ
ಮೆಮೊರಿ ಅಥವಾ ಸ್ಥಳದಲ್ಲಿ ಅದನ್ನು ಬದಲಾಯಿಸಲು.

420
00:22:52,210 --> 00:22:55,630
ಮತ್ತೆ, ನೀವು ಎಂದು ನೆನಪಿಡಿ
ಅನೇಕ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ರಚಿಸಲು ಆದ್ದರಿಂದ ನೀವು

421
00:22:55,630 --> 00:23:00,390
ಸಹ ಮರಣದಂಡನೆ ಮುಂದುವರೆಸಬಹುದು, ತೆರಳಿ
ಕೋಡ್ ಹೆಚ್ಚಿನ ಭಾಗಗಳು ಮೇಲೆ,

422
00:23:00,390 --> 00:23:04,790
ಮತ್ತು ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವಿರಾಮ ಮಾಡುತ್ತೇವೆ
ಮುಂದಿನ ಬ್ರೇಕ್ ಹಂತದಲ್ಲಿ.

423
00:23:04,790 --> 00:23:07,760
>> ವಾಸ್ತವವಾಗಿ ಅತ್ಯಾಧುನಿಕ ಇಲ್ಲ
ದೋಷಸೂಚಕವು, ಹಾಗೂ.

424
00:23:07,760 --> 00:23:10,170
ಆದರೆ ನಾವು ನೀವು ನೋಡಿ ಮಾಡುತ್ತೇವೆ
ಆನಂತರದ ವೀಡಿಯೊಗಳಿಗೆ

425
00:23:10,170 --> 00:23:14,090
ನಿಜವಾಗಿಯೂ ಹೇಗೆ ಹೊರತುಪಡಿಸಿ ಕೀಟಲೆ ಸಲುವಾಗಿ
ಆ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು.

426
00:23:14,090 --> 00:23:15,990
ಈಗ, ಧನ್ಯವಾದಗಳು
ವೀಕ್ಷಿಸಲು ತುಂಬಾ.

427
00:23:15,990 --> 00:23:18,080
ಮತ್ತು ಅದೃಷ್ಟ ಡೀಬಗ್.