1
00:00:00,000 --> 00:00:06,030
>> [ಸಂಗೀತ]

2
00:00:06,030 --> 00:00:08,390
>> ಡೌಗ್ LLOYD: ಪಾಯಿಂಟರ್ಸ್, ಇಲ್ಲಿ ನಾವು.

3
00:00:08,390 --> 00:00:11,080
ಬಹುಶಃ ನಾನು
ಅತ್ಯಂತ ಕಷ್ಟ ವಿಷಯ

4
00:00:11,080 --> 00:00:12,840
ನಾವು CS50 ಬಗ್ಗೆ ಮಾತನಾಡುವುದು.

5
00:00:12,840 --> 00:00:15,060
ಮತ್ತು ನೀವು ಓದಿದ ವೇಳೆ
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಏನು

6
00:00:15,060 --> 00:00:19,080
ನೀವು ಸ್ವಲ್ಪ ಇರಬಹುದು ಮೊದಲು
ಬೆದರಿಸುವ ಈ ವೀಡಿಯೊ ಹೋಗುವಾಗ.

7
00:00:19,080 --> 00:00:21,260
ಇದು ಪಾಯಿಂಟರ್ಸ್ ನಿಜ
ನೀವು ಸಾಮರ್ಥ್ಯವನ್ನು ಅವಕಾಶ ಇಲ್ಲ

8
00:00:21,260 --> 00:00:23,740
ಬಹುಶಃ ಅಪ್ ತಿರುಗಿಸಲು
ಬಹಳ ಕೆಟ್ಟದಾಗಿ ನೀವು ಇರುವಾಗ

9
00:00:23,740 --> 00:00:27,450
ಅಸ್ಥಿರ ಮತ್ತು ಡೇಟಾ ಕೆಲಸ,
ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕುಸಿತಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

10
00:00:27,450 --> 00:00:30,490
ಆದರೆ ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಆರ್
ಮತ್ತು ಅವರು ನಮಗೆ ನಿಜವಾಗಿಯೂ ಶ್ರೇಷ್ಠ ಮಾರ್ಗವಾಗಿದೆ ಅವಕಾಶ

11
00:00:30,490 --> 00:00:33,340
ಮತ್ತೆ ಡೇಟಾ ರವಾನಿಸಲು ಮತ್ತು
ಮುಂದಕ್ಕೆ ಕಾರ್ಯಗಳನ್ನು ನಡುವೆ,

12
00:00:33,340 --> 00:00:35,490
ನಾವು ಇಲ್ಲದಿದ್ದರೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ.

13
00:00:35,490 --> 00:00:37,750
>> ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ನಿಜವಾಗಿಯೂ
ರೈಲು ಇಲ್ಲಿ ನೀವು

14
00:00:37,750 --> 00:00:41,060
ನೀವು ಉತ್ತಮ ಪಾಯಿಂಟರ್ ಶಿಸ್ತು, ಆದ್ದರಿಂದ ಗೆ
ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಬಹುದಾದ

15
00:00:41,060 --> 00:00:43,850
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಉತ್ತಮ ಮಾಡಲು.

16
00:00:43,850 --> 00:00:48,220
ನಾನು ಹೇಳಿದಂತೆ ಪಾಯಿಂಟರ್ಸ್ ನಮಗೆ ಬೇರೆ ನೀಡಲು
ವೇ ಕ್ರಿಯೆಗಳು ನಡುವೆ ಮಾಹಿತಿ ರವಾನಿಸಲು.

17
00:00:48,220 --> 00:00:50,270
ಈಗ ನೀವು ಮರುಪಡೆಯಲು ವೇಳೆ
ಹಿಂದಿನ ವೀಡಿಯೊ, ಯಾವಾಗ

18
00:00:50,270 --> 00:00:53,720
ನಾವು ಬಗ್ಗೆ
ವೇರಿಯಬಲ್ ವ್ಯಾಪ್ತಿ, ನಾನು ಹೇಳಿದಂತೆ

19
00:00:53,720 --> 00:01:00,610
ನಾವು ನಡುವೆ ಹೋಗುವ ಎಲ್ಲಾ ಡೇಟಾ
ಸಿ ಕಾರ್ಯಗಳನ್ನು ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಲಾಗಿದೆ.

20
00:01:00,610 --> 00:01:03,070
ಮತ್ತು ನಾನು ಬಳಸಿದೆ ಇರಬಹುದು
ಪದವನ್ನು ನಾನು ಅರ್ಥ, ಏನು

21
00:01:03,070 --> 00:01:07,170
ನಾವು ಮಾಹಿತಿಗಳ ನಕಲು ಮಾಯವಾಗುತ್ತಿವೆ ಆಗಿತ್ತು.

22
00:01:07,170 --> 00:01:12,252
ನಾವು ಒಂದು ಕಾರ್ಯ ವೇರಿಯಬಲ್ ಹಾದುಹೋದಾಗ,
ನಾವು ವಾಸ್ತವವಾಗಿ ವೇರಿಯಬಲ್ ಸಾಗುವ ಇಲ್ಲ

23
00:01:12,252 --> 00:01:13,210
ಕಾರ್ಯ, ಬಲ?

24
00:01:13,210 --> 00:01:17,670
ನಾವು ಪ್ರತಿಯನ್ನು ಹಾದುಹೋಗುವ ನೀವು
ಕಾರ್ಯ ಡೇಟಾವನ್ನು.

25
00:01:17,670 --> 00:01:20,760
ಕಾರ್ಯ ಏನು ಇದು ಮಾಡುತ್ತದೆ
ಮತ್ತು ಇದು ಕೆಲವು ಮೌಲ್ಯದ ಲೆಕ್ಕಾಚಾರ,

26
00:01:20,760 --> 00:01:23,180
ಮತ್ತು ಬಹುಶಃ ನಾವು ಆ ಮೌಲ್ಯವನ್ನು ಬಳಸುತ್ತಾರೆ
ಅದನ್ನು ಮತ್ತೆ ನೀಡುತ್ತದೆ.

27
00:01:23,180 --> 00:01:26,700
>> ಅಪವಾದವಾಗಿದೆ ಇರಲಿಲ್ಲ
ಮೌಲ್ಯ ವರ್ಗಾಯಿಸುವ ಈ ನಿಯಮವನ್ನು

28
00:01:26,700 --> 00:01:31,210
ಮತ್ತು ನಾವು ಏನು ಎಂದು ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ
ಈ ವೀಡಿಯೊ ನಂತರ ಸ್ವಲ್ಪ.

29
00:01:31,210 --> 00:01:34,880
ನಾವು ಬದಲಿಗೆ ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಿದರೆ
ಅಸ್ಥಿರ ಬಳಸಿ,

30
00:01:34,880 --> 00:01:38,180
ಅಥವಾ ಅಸ್ಥಿರ ಬಳಸಿ ಬದಲು
ತಮ್ಮನ್ನು ಅಥವಾ ಅಸ್ಥಿರ ಪ್ರತಿಗಳನ್ನು,

31
00:01:38,180 --> 00:01:43,790
ನಾವು ಈಗ ಸುಮಾರು ಚರಾಂಕಗಳ ರವಾನಿಸಬಹುದು
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ನಡುವೆ.

32
00:01:43,790 --> 00:01:46,550
ಈ ನಾವು ಮಾಡಿದರೆ ಅಂದರೆ
ಒಂದು ಕಾರ್ಯ ಬದಲಾವಣೆ,

33
00:01:46,550 --> 00:01:49,827
ಬದಲಾವಣೆ ವಾಸ್ತವವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಬೇರೆ ಕಾರ್ಯದಲ್ಲಿ ಪ್ರಭಾವ.

34
00:01:49,827 --> 00:01:52,160
ಮತ್ತೆ, ಈ ವಿಷಯ
ನಾವು, ಹಿಂದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

35
00:01:52,160 --> 00:01:56,979
ಮತ್ತು ನೀವು ಎಂದಾದರೂ ಸ್ವ್ಯಾಪ್ ಪ್ರಯತ್ನಿಸಿದ ವೇಳೆ
ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಎರಡು ವ್ಯತ್ಯಾಸಗಳ ಮೌಲ್ಯವನ್ನು,

36
00:01:56,979 --> 00:01:59,270
ಈ ಸಮಸ್ಯೆಯನ್ನು ಗಮನಕ್ಕೆ ಬಂದಿದೆ
ತೆವಳುವ ರೀತಿಯ, ಬಲ?

37
00:01:59,270 --> 00:02:04,340
>> ನಾವು X ಮತ್ತು Y ಮತ್ತು ನಾವು ವಿನಿಮಯ ಬಯಸಿದರೆ
ಸ್ವಾಪ್ ಎಂಬ ಕ್ರಿಯೆಯ ಅವುಗಳನ್ನು ರವಾನಿಸಲು,

38
00:02:04,340 --> 00:02:08,680
ಕಾರ್ಯದ ಒಳಗೆ ವಿನಿಮಯ
ಅಸ್ಥಿರ ವಿನಿಮಯ ಮೌಲ್ಯಗಳನ್ನು ಮಾಡಲು.

39
00:02:08,680 --> 00:02:12,600
ಒಂದು ಎರಡು ಆಗುತ್ತದೆ, ಎರಡು ಆಗುತ್ತದೆ
ಒಂದು, ಆದರೆ ನಾವು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ

40
00:02:12,600 --> 00:02:16,890
ಮೂಲ ಏನು ಬದಲಾಯಿಸಬಹುದು
ಕಾರ್ಯ, ಕಾಲರ್ ನಲ್ಲಿ.

41
00:02:16,890 --> 00:02:19,550
ಏಕೆಂದರೆ ನಾವು, ನಾವು ಆರ್ ಮಾತ್ರ
ಅವುಗಳನ್ನು ನಕಲು ಕೆಲಸ.

42
00:02:19,550 --> 00:02:24,760
ಆದರೂ ಪಾಯಿಂಟರ್ಸ್, ನಾವು
ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಕ್ಕೆ X ಮತ್ತು Y ರವಾನಿಸಲು.

43
00:02:24,760 --> 00:02:26,960
ಆ ಕಾರ್ಯವನ್ನು ಮಾಡಬಹುದು
ಅವರ ಜೊತೆ ಏನೋ.

44
00:02:26,960 --> 00:02:29,250
ಮತ್ತು ಆ ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು
ವಾಸ್ತವವಾಗಿ ಬದಲಾಯಿಸಬಹುದು.

45
00:02:29,250 --> 00:02:33,710
ಆದ್ದರಿಂದ ಸಾಕಷ್ಟು ಬದಲಾವಣೆಯ
ಡೇಟಾ ಕೆಲಸ ನಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು.

46
00:02:33,710 --> 00:02:36,100
>> ನಾವು ಧುಮುಕುವುದಿಲ್ಲ ಮೊದಲು
ಪಾಯಿಂಟರ್ಸ್, ನಾನು ಮೌಲ್ಯದ ಇಲ್ಲಿದೆ ಆಲೋಚಿಸುತ್ತೀರಿ

47
00:02:36,100 --> 00:02:38,580
ಕೆಲವು ನಿಮಿಷಗಳ ತೆಗೆದುಕೊಳ್ಳುವ
ಇಲ್ಲಿ ಮೂಲಭೂತ ಹಿಂದೆ ಹೋಗಿ.

48
00:02:38,580 --> 00:02:41,000
ಮತ್ತು ಹೇಗೆ ಒಂದು ನೋಟ ಹೊಂದಿವೆ
ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿ ಕೃತಿಗಳು

49
00:02:41,000 --> 00:02:45,340
ಈ ಎರಡು ವಿಷಯಗಳ ಹೋಗುವ ಕಾರಣ
ವಾಸ್ತವವಾಗಿ ಬಹಳ ಹೆಣೆದುಕೊಂಡಿದೆ ಎಂದು.

50
00:02:45,340 --> 00:02:48,480
ನೀವು ಬಹುಶಃ ತಿಳಿದಿರುವಂತೆ,
ನಿಮ್ಮ ಗಣಕವನ್ನು

51
00:02:48,480 --> 00:02:51,310
ನೀವು ಒಂದು ಹಾರ್ಡ್ ಡ್ರೈವ್ ಅಥವಾ
ಬಹುಶಃ ಘನ ಡ್ರೈವ್,

52
00:02:51,310 --> 00:02:54,430
ಕಡತ ಸಂಗ್ರಹ ಸ್ಥಳ ಕೆಲವು ರೀತಿಯ.

53
00:02:54,430 --> 00:02:57,950
ಇದು ಎಲ್ಲೋ ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲಿದೆ
250 ಗಿಗಾಬೈಟ್ ನೆರೆಹೊರೆಯ

54
00:02:57,950 --> 00:02:59,810
ಈಗ ಟೆರಾಬೈಟ್ಗಳ ಬಹುಶಃ ಒಂದೆರಡು.

55
00:02:59,810 --> 00:03:02,270
ಮತ್ತು ಇದು ಅಲ್ಲಿ ಅಷ್ಟೆ ನಿಮ್ಮ
ಕಡತಗಳನ್ನು ಅಂತಿಮವಾಗಿ, ಲೈವ್

56
00:03:02,270 --> 00:03:04,870
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಮುಚ್ಚಿ ಸಹ
ಆಫ್, ನೀವು ಮತ್ತೆ ಮಾಡಬಹುದು

57
00:03:04,870 --> 00:03:09,190
ಮತ್ತು ನಿಮ್ಮ ಕಡತಗಳನ್ನು ಇವೆ ಕಾಣುವಿರಿ
ಮತ್ತೆ ಗಣಕವು ಮರಳಿ ಬೂಟ್ ಮಾಡಿದ ನಂತರ.

58
00:03:09,190 --> 00:03:14,820
ಆದರೆ ಒಂದು ಹಾರ್ಡ್ ಡಿಸ್ಕ್ ಡ್ರೈವ್ ಡಿಸ್ಕ್ ಡ್ರೈವ್ಗಳು,
ಎಚ್ಡಿಡಿಯ, ಅಥವಾ ಒಂದು ಘನ ಡ್ರೈವ್, ಒಂದು SSD,

59
00:03:14,820 --> 00:03:16,050
ಕೇವಲ ಸಂಗ್ರಹ ಜಾಗವನ್ನು ಇವೆ.

60
00:03:16,050 --> 00:03:20,400
>> ನಾವು ವಾಸ್ತವವಾಗಿ ಏನು ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ
ಹಾರ್ಡ್ ಡಿಸ್ಕ್ ಎಂದು ದಶಮಾಂಶ,

61
00:03:20,400 --> 00:03:22,080
ಅಥವಾ ಒಂದು ಘನ ಡ್ರೈವ್ ರಲ್ಲಿ.

62
00:03:22,080 --> 00:03:24,950
ವಾಸ್ತವವಾಗಿ ಬದಲಾಯಿಸಲು ಸಲುವಾಗಿ
ಡೇಟಾ ಅಥವಾ ಇದು ತಿರುಗಾಡಲು,

63
00:03:24,950 --> 00:03:28,800
ನಾವು ಅದನ್ನು ಸ್ಥಳಾಂತರಿಸಲು
ರಾಮ್, ಇಂಟರ್ನೆಟ್ ಪ್ರವೇಶ ನೀಡುಗ.

64
00:03:28,800 --> 00:03:31,170
ಈಗ ರಾಮ್, ನೀವು ಬಹಳಷ್ಟು
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ನಲ್ಲಿ ಕಡಿಮೆ.

65
00:03:31,170 --> 00:03:34,185
ನೀವು ಎಲ್ಲೋ ಹೊಂದಿರಬಹುದು
512 ಮೆಗಾಬೈಟ್ ಪಕ್ಕದಲ್ಲಿ

66
00:03:34,185 --> 00:03:38,850
ನೀವು ಒಂದು ಹಳೆಯ ಕಂಪ್ಯೂಟರ್ ಇದ್ದರೆ,
ಬಹುಶಃ ಎರಡು, ನಾಲ್ಕು, ಎಂಟು, 16,

67
00:03:38,850 --> 00:03:41,820
ಸಂಭವನೀಯವಾಗಿ ಸ್ವಲ್ಪ
ಹೆಚ್ಚು, RAM ನ ಗಿಗಾಬೈಟ್.

68
00:03:41,820 --> 00:03:46,390
ಆದ್ದರಿಂದ ಸಣ್ಣ, ಆದರೆ ಇಲ್ಲಿದೆ
ಅಲ್ಲಿ ಬಾಷ್ಪಶೀಲ ದಶಮಾಂಶ ಎಲ್ಲಾ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

69
00:03:46,390 --> 00:03:48,270
ನಾವು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬಹುದು ಅಲ್ಲೇ.

70
00:03:48,270 --> 00:03:53,350
ಆದರೆ ನಾವು ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಆಫ್ ಮಾಡಿದಾಗ,
ರಾಮ್ ದಶಮಾಂಶ ಎಲ್ಲಾ ನಾಶವಾಗುತ್ತದೆ.

71
00:03:53,350 --> 00:03:57,150
>> ನಾವು ಹಾರ್ಡ್ ಡಿಸ್ಕ್ ಮಾಡಬೇಕು ಏಕೆ ಆ ನ
ಇದು ಹೆಚ್ಚು ಶಾಶ್ವತ ಸ್ಥಳ,

72
00:03:57,150 --> 00:03:59,720
ಇದು exists- ಆದ್ದರಿಂದ ಇದು ಎಂದು
ನಿಜವಾಗಿಯೂ ಕೆಟ್ಟ ವೇಳೆ ಪ್ರತಿ ಬಾರಿ ನಾವು

73
00:03:59,720 --> 00:04:03,310
ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಆಫ್ ಪ್ರತಿ
ನಮ್ಮ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಕಡತ ನಾಶಮಾಡುತ್ತದೆ ಮಾಡಲಾಯಿತು.

74
00:04:03,310 --> 00:04:05,600
ನಾವು ರಾಮ್ ಒಳಗೆ ಕೆಲಸ.

75
00:04:05,600 --> 00:04:09,210
ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವ ನೀವು
ಮೆಮೊರಿ, ಬಹುಮಟ್ಟಿಗೆ, CS50 ರಲ್ಲಿ,

76
00:04:09,210 --> 00:04:15,080
ನಾವು ರಾಮ್ ಅಲ್ಲದ ಹಾರ್ಡ್ ಡಿಸ್ಕ್ ಬಗ್ಗೆ ನೀವು.

77
00:04:15,080 --> 00:04:18,657
>> ನಾವು ಮೆಮೊರಿ ವಸ್ತುಗಳ ಸರಿಸಲು,
ಇದು ಜಾಗವನ್ನು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

78
00:04:18,657 --> 00:04:20,740
ಡೇಟಾ ಪ್ರಕಾರಗಳು ಎಲ್ಲ
ನಾವು ಕೆಲಸ ಮಾಡಿದ

79
00:04:20,740 --> 00:04:23,480
ಅಪ್ ವಿವಿಧ ತೆಗೆದುಕೊಳ್ಳಲು
ರಾಮ್ ಜಾಗವನ್ನು ಪ್ರಮಾಣದ.

80
00:04:23,480 --> 00:04:27,600
ಆದ್ದರಿಂದ ಪ್ರತಿ ಬಾರಿ ನೀವು ಒಂದು ಪೂರ್ಣಾಂಕ ರಚಿಸಲು
ಮೆಮೊರಿ ವೇರಿಯಬಲ್, ನಾಲ್ಕು ಬೈಟ್ಗಳು

81
00:04:27,600 --> 00:04:30,750
ನೀವು ರಾಮ್ ಮೀಸಲಿಡಲಾಗಿತ್ತು
ಪೂರ್ಣಾಂಕ ಕೆಲಸ ಮಾಡಬಹುದು.

82
00:04:30,750 --> 00:04:34,260
ನೀವು ಪೂರ್ಣಾಂಕ ಘೋಷಿಸಿದ ಮಾಡಬಹುದು,
ಅದನ್ನು ಬದಲಾಯಿಸಲು, ಇದು ನಿಯೋಜಿಸಲು

83
00:04:34,260 --> 00:04:36,700
ಹೆಚ್ಚಾಗುತ್ತದೆ ಈ ಕೆಳಗಿನ 10
ಒಂದು, ಹೀಗೆ ಮೇಲೆ.

84
00:04:36,700 --> 00:04:39,440
ಆಗಬೇಕಿದೆ ಎಲ್ಲಾ
ರಾಮ್, ಮತ್ತು ನೀವು ನಾಲ್ಕು ಬೈಟ್ಗಳು ಪಡೆಯಲು

85
00:04:39,440 --> 00:04:42,550
ಪ್ರತಿ ಫಾರ್ ಕೆಲಸ
ನೀವು ರಚಿಸಿದ ಪೂರ್ಣಾಂಕ.

86
00:04:42,550 --> 00:04:45,410
>> ಪ್ರತಿ ಪಾತ್ರವನ್ನು ನೀವು
ರಚಿಸಲು ಒಂದು ಬೈಟ್ ಪಡೆಯುತ್ತದೆ.

87
00:04:45,410 --> 00:04:48,160
ಆ ಜಾಗ ಎಷ್ಟು ಇಲ್ಲಿದೆ
ಒಂದು ಅಕ್ಷರವನ್ನು ಸಂಗ್ರಹಿಸಿಡುವ ಅಗತ್ಯವಿದೆ.

88
00:04:48,160 --> 00:04:51,310
ಪ್ರತಿ ಫ್ಲೋಟ್, ಒಂದು ನಿಜವಾದ
ಸಂಖ್ಯೆ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಗೆಟ್ಸ್

89
00:04:51,310 --> 00:04:53,390
ಇದು ಎರಡು ಪಟ್ಟು ಹೊರತು
ಪ್ರಿಸಿಷನ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್

90
00:04:53,390 --> 00:04:56,510
ಅನುಮತಿಸುತ್ತದೆ ಇದು ಸಂಖ್ಯೆ,
ಹೆಚ್ಚು ನಿಖರ ಅಥವಾ ಹೆಚ್ಚು ಅಂಕೆಗಳನ್ನು ಹೊಂದಿರುವಾಗ

91
00:04:56,510 --> 00:04:59,300
ದಶಮಾಂಶ ಬಿಂದುವಿನ ನಂತರ
ನಿಖರ ಕಳೆದುಕೊಳ್ಳದೇ,

92
00:04:59,300 --> 00:05:01,820
ಇದು ಮೆಮೊರಿ ಎಂಟು ಬೈಟ್ಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

93
00:05:01,820 --> 00:05:06,730
ದೀರ್ಘ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ, ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳು
ಸಹ ಮೆಮೊರಿ ಎಂಟು ಬೈಟ್ಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

94
00:05:06,730 --> 00:05:09,000
ಎಷ್ಟು ಮೆಮೊರಿ ಬೈಟ್ಗಳು
ತಂತಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಇಲ್ಲ?

95
00:05:09,000 --> 00:05:12,990
ಅಲ್ಲದೆ ನ ಪ್ರಶ್ನೆ ಒಂದು ಪಿನ್ ಹಾಕಲು ಅವಕಾಶ
ಈಗ, ಆದರೆ ನಾವು ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ.

96
00:05:12,990 --> 00:05:17,350
>> ಆದ್ದರಿಂದ ಮತ್ತೆ ಮೆಮೊರಿ ಈ ಕಲ್ಪನೆಯನ್ನು ಎಂದು
ಬೈಟ್ ಗಾತ್ರದ ಕಣಗಳ ದೊಡ್ಡ ವ್ಯೂಹ.

97
00:05:17,350 --> 00:05:20,871
ನಿಜಕ್ಕೂ ಅದು ಅಷ್ಟೆ, ಅದು
ಜೀವಕೋಶಗಳು ಕೇವಲ ವ್ಯೂಹಗಳನ್ನು,

98
00:05:20,871 --> 00:05:23,370
ಬೇರಾವುದೇ ರಚನೆಯ ಎಂದು
ನಿಮಗೆ ಪರಿಚಿತವಾಗಿರುವ ಮತ್ತು ನೋಡಿ,

99
00:05:23,370 --> 00:05:26,430
ಪ್ರತಿ ಅಂಶ ಹೊರತುಪಡಿಸಿ ಒಂದು ಬೈಟ್ ಅಗಲವಿದೆ.

100
00:05:26,430 --> 00:05:30,030
ಮತ್ತು ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಂತಹ
ಪ್ರತಿ ಅಂಶ ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ.

101
00:05:30,030 --> 00:05:32,120
ಒಂದು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ
ಒಂದು ಇಂಡೆಕ್ಸ್ ಮತ್ತು ನಾವು ಹೊಂದಿದೆ

102
00:05:32,120 --> 00:05:36,302
ಕರೆಯಲ್ಪಡುವ ಮಾಡಲು ಸೂಚ್ಯಂಕ ಬಳಸಬಹುದು
ರಚನೆಯ ಮೇಲೆ ಸ್ವೇಚ್ಛೆಯಾಗಿ ಪ್ರವೇಶಿಸಲು.

103
00:05:36,302 --> 00:05:38,510
ನಾವು ಆರಂಭವಾಗುವುದು ಇಲ್ಲ
ಸರಣಿ ಪ್ರಾರಂಭ

104
00:05:38,510 --> 00:05:40,569
ಪ್ರತಿ ಮೂಲಕ ಮರಳಿ
ಏಕ ಅಂಶ ಅದರ

105
00:05:40,569 --> 00:05:41,860
ನಾವು ಹುಡುಕುತ್ತಿರುವ ಕಂಡುಹಿಡಿಯಲು.

106
00:05:41,860 --> 00:05:45,790
ನಾವು ನಾನು ಪಡೆಯಲು ಬಯಸುವ, ಹೇಳಬಹುದು
15 ಅಂಶ ಅಥವಾ 100 ನೇ ಅಂಶ.

107
00:05:45,790 --> 00:05:49,930
ಮತ್ತು ನೀವು ಎಂದು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ
ಮತ್ತು ನೀವು ಹುಡುಕುತ್ತಿರುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು.

108
00:05:49,930 --> 00:05:54,460
>> ಅದೇ ರೀತಿ ಪ್ರತಿ ಸ್ಥಳ
ನೆನಪಿಗಾಗಿ ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ.

109
00:05:54,460 --> 00:05:57,320
ನಿಮ್ಮ ಮೆಮೊರಿ ಮಾಡಬಹುದು
ಈ ರೀತಿಯ ನೋಡಲು.

110
00:05:57,320 --> 00:06:01,420
ಇಲ್ಲಿ ಒಂದು ಸಣ್ಣ ಪಡೆ
ಮೆಮೊರಿ, ಈ ಮೆಮೊರಿಯ 20 ಬೈಟ್ಸ್.

111
00:06:01,420 --> 00:06:04,060
ಮೊದಲ 20 ಬೈಟ್ಗಳು ಏಕೆಂದರೆ ನನ್ನ
ಅಲ್ಲಿ ಕೆಳಭಾಗದಲ್ಲಿ ವಿಳಾಸಗಳನ್ನು

112
00:06:04,060 --> 00:06:08,890
3, 2, 1, 0, ಮತ್ತು ಆದ್ದರಿಂದ
19 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಅಪ್ ಮೇಲೆ.

113
00:06:08,890 --> 00:06:13,190
ನಾನು ಅಸ್ಥಿರ ಘೋಷಿಸಿದ ಮತ್ತು
ನಾನು ಅವರೊಂದಿಗೆ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿದಾಗ,

114
00:06:13,190 --> 00:06:15,470
ವ್ಯವಸ್ಥೆಯ ಸೆಟ್ ಹೋಗುವ
ನನಗೆ ಪಕ್ಕಕ್ಕೆ ಕೆಲವು ಜಾಗವನ್ನು

115
00:06:15,470 --> 00:06:17,595
ಈ ನೆನಪಿಗಾಗಿ ಕೆಲಸ
ನನ್ನ ಅಸ್ಥಿರ.

116
00:06:17,595 --> 00:06:21,610
ಹಾಗಾಗಿ ಚಾರ್ ಸಿ ರಾಜಧಾನಿ ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಬಹುದು
ಎಚ್ ಮತ್ತು ತೀರುತ್ತದೆ?

117
00:06:21,610 --> 00:06:23,880
ಸರಿ ವ್ಯವಸ್ಥೆಯ ಹೋಗುತ್ತದೆ
ನನಗೆ ಒಂದು ಬೈಟ್ ಮೀಸಲಿಡಲಾಗಿತ್ತು.

118
00:06:23,880 --> 00:06:27,870
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಬೈಟ್ ಸಂಖ್ಯೆ ಆಯ್ಕೆ
ನಾಲ್ಕು, ವಿಳಾಸ ನಾಲ್ಕು ನಲ್ಲಿ ಬೈಟ್,

119
00:06:27,870 --> 00:06:31,310
ಮತ್ತು ಇದು ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವೇನು
ನನಗೆ ಅಲ್ಲಿ ಅಕ್ಷರದ ರಾಜಧಾನಿ ಎಚ್.

120
00:06:31,310 --> 00:06:34,350
ನಾನು ಇಂಟ್ ವೇಗ ಹೇಳಿದರೆ
ಮಿತಿ ಅಷ್ಟೇ, 65 ಸಮ

121
00:06:34,350 --> 00:06:36,806
ಪಕ್ಕಕ್ಕೆ ನಾಲ್ಕು ಸೆಟ್ ಹೋಗುವ
ನನಗೆ ಮೆಮೊರಿ ಬೈಟ್ಗಳು.

122
00:06:36,806 --> 00:06:39,180
ಮತ್ತು ಇದು ಆ ಚಿಕಿತ್ಸೆ ವಿಶೇಷವೇನು
ಒಂದು ಘಟಕವಾಗಿ ನಾಲ್ಕು ಬೈಟ್ಗಳು

123
00:06:39,180 --> 00:06:41,305
ನಾವು ಕೆಲಸ ಏನನ್ನು ಏಕೆಂದರೆ
ಇಲ್ಲಿ ಒಂದು ಪೂರ್ಣಾಂಕ.

124
00:06:41,305 --> 00:06:44,350
ಮತ್ತು ಹಾಗಾದರೆ 65 ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವೇನು.

125
00:06:44,350 --> 00:06:47,000
>> ಈಗ ಈಗಾಗಲೇ ನಾನು ರೀತಿಯ ಮನುಷ್ಯ
ನೀವು ಸುಳ್ಳು ಒಂದು ಬಿಟ್ ಹೇಳುವ,

126
00:06:47,000 --> 00:06:50,150
ಸರಿ, ನಾವು ತಿಳಿದಿರುವ ಕಾರಣ
ಕಂಪ್ಯೂಟರ್ ಬೈನರಿ ಕೆಲಸ.

127
00:06:50,150 --> 00:06:53,100
ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ
ಅಗತ್ಯವಾಗಿ ಒಂದು ಬಂಡವಾಳ ಎಚ್ ಏನು

128
00:06:53,100 --> 00:06:57,110
ಅಥವಾ 65 ಅವರು ಮಾತ್ರ, ಏನು
ಬೈನರಿ, ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಅರ್ಥ.

129
00:06:57,110 --> 00:06:59,000
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಏನು
ನಾವು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ನೀವು

130
00:06:59,000 --> 00:07:03,450
ಅಕ್ಷರ H ಮತ್ತು 65, ಅಲ್ಲ
ಆದರೆ ಅವಳಿ ನಿರೂಪಣೆಗಳು

131
00:07:03,450 --> 00:07:06,980
ಅದರ ಇದು ನೋಡಲು ಒಂದು
ಈ ರೀತಿಯ ಏನಾದರೂ.

132
00:07:06,980 --> 00:07:10,360
ಮತ್ತು ಅದರಲ್ಲೂ ನಿರ್ದಿಷ್ಟವಾಗಿ
ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ಸನ್ನಿವೇಶದಲ್ಲಿ,

133
00:07:10,360 --> 00:07:13,559
ಇದು, ಕೇವಲ ಇದನ್ನು ಭೂಶಿರ ಹಿಂದಿರುಗಬಹುದೆಂದು
ಅದು ಒಂದು ನಾಲ್ಕು ಎಂದು ಚಿಕಿತ್ಸೆ ಹಿಂದಿರುಗಬಹುದೆಂದು

134
00:07:13,559 --> 00:07:15,350
ಬೈಟ್ ಪಡೆ ಅಗತ್ಯವಾಗಿ
ನಿಜವಾಗಿ ಇಂದಿನ ವಿಶೇಷವೇನು

135
00:07:15,350 --> 00:07:19,570
ನಾಲ್ಕು ಒಂದು ಬೈಟ್ ಭಾಗಗಳಲ್ಲಿ ಎಂದು ಚಿಕಿತ್ಸೆ,
ಈ ರೀತಿಯ ನೋಡಲು ಇರಬಹುದು.

136
00:07:19,570 --> 00:07:22,424
ಮತ್ತು ಈ ಅಲ್ಲ
ಸಂಪೂರ್ಣವಾಗಿ ನಿಜವಾದ ಎರಡೂ,

137
00:07:22,424 --> 00:07:24,840
ಕರೆಯುವುದನ್ನು ಏಕೆಂದರೆ
ನಾವು ಇಲ್ಲ ಒಂದು endianness,

138
00:07:24,840 --> 00:07:26,965
ಈಗ ಪಡೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಆದರೆ
ನೀವು ಬಗ್ಗೆ ಕುತೂಹಲಕಾರಿ ಆರ್,

139
00:07:26,965 --> 00:07:29,030
ನೀವು ಸ್ವಲ್ಪ ಮೇಲೆ ಓದಬಹುದು
ಮತ್ತು ದೊಡ್ಡ endianness.

140
00:07:29,030 --> 00:07:31,640
ಆದರೆ ಈ ವಾದವನ್ನು ಸಲುವಾಗಿ,
ಈ ವೀಡಿಯೊ ಸಲುವಾಗಿ,

141
00:07:31,640 --> 00:07:34,860
ಕೇವಲ ಆ, ಊಹಿಸುತ್ತವೆ
ವಾಸ್ತವವಾಗಿ, ಹೇಗೆ ಸಂಖ್ಯೆ 65 ಎಂದು

142
00:07:34,860 --> 00:07:36,970
ನಿರೂಪಿಸಬಹುದು
ಪ್ರತಿ ಗಣಕದಲ್ಲಿ ಮೆಮೊರಿ,

143
00:07:36,970 --> 00:07:38,850
ಇದು ಸಂಪೂರ್ಣ ಸತ್ಯವೇನಲ್ಲ ಆದರೂ.

144
00:07:38,850 --> 00:07:41,700
>> ಆದರೆ ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಪಡೆಯಲು ಅವಕಾಶ
ಸಂಪೂರ್ಣವಾಗಿ ಎಲ್ಲಾ ಬೈನರಿ ತ್ಯಜಿಸುವುದು,

145
00:07:41,700 --> 00:07:44,460
ಮತ್ತು ಕೇವಲ ಗಂ ಬಗ್ಗೆ
ಮತ್ತು 65, ಇದು ತುಂಬಾ ಸುಲಭ

146
00:07:44,460 --> 00:07:47,900
ಹಾಗೆ ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು
ಮಾನವರಷ್ಟೇ ಎಂದು.

147
00:07:47,900 --> 00:07:51,420
ಸರಿ, ಇದು ತೋರುತ್ತದೆ ಆದ್ದರಿಂದ ಬಹುಶಃ ಒಂದು
ಸ್ವಲ್ಪ ಯಾದೃಚ್ಛಿಕ ಎಂದು ಉಳಿಸಲು ಯಾವ I've- ನನ್ನ ವ್ಯವಸ್ಥೆ

148
00:07:51,420 --> 00:07:55,130
ಬೈಟ್ಗಳು 5, 6, 7 ನನಗೆ ಕೊಡಲಿಲ್ಲ
ಮತ್ತು 8 ಪೂರ್ಣಾಂಕ ಶೇಖರಿಸಿಡಲು.

149
00:07:55,130 --> 00:07:58,580
ಎಂದು ಒಂದು ಕಾರಣ ಕೂಡ ಇಲ್ಲ ಇದು
ಇದೀಗ ಬರಲು, ಆದರೆ ಸಾಕು ಆದರೆ

150
00:07:58,580 --> 00:08:00,496
ಇದು ಏನು ಹೇಳಲು
ಕಂಪ್ಯೂಟರ್ ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವ

151
00:08:00,496 --> 00:08:02,810
ಬಹುಶಃ ಅದರ ಕಡೆಯಿಂದ ಉತ್ತಮ ಸರಿಸಿ.

152
00:08:02,810 --> 00:08:06,020
ನಾನೇ ಎಂದು ಮೆಮೊರಿ ನೀಡುವುದಿಲ್ಲ
ಅಗತ್ಯವಾಗಿ ಮತ್ತೆ ಮತ್ತೆ.

153
00:08:06,020 --> 00:08:10,490
ಈಗ ಅದನ್ನು ವಿಶೇಷವೇನು ಆದರೂ
ನಾನು ಸರಮಾಲೆಯನ್ನೇ ಪಡೆಯಲು ಬಯಸಿದರೆ,

154
00:08:10,490 --> 00:08:13,080
ಉಪನಾಮ ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ನಾನು ಬಯಸುವ
ಹಾಗಾದರೆ ಲಾಯ್ಡ್ ಹಾಕಲು.

155
00:08:13,080 --> 00:08:18,360
ನಾನು ಹೊಂದಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಪಾತ್ರ, ಆ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರದ ಇಲ್ಲಿದೆ

156
00:08:18,360 --> 00:08:21,330
ಒಂದು ಅಗತ್ಯವಿದೆ ಹೋಗಿ
ಪಾತ್ರ ಮೆಮೊರಿ ಒಂದು ಬೈಟ್.

157
00:08:21,330 --> 00:08:26,230
ನನ್ನ ರಚನೆಯ ಒಳಗೆ ಲಾಯ್ಡ್ ಪುಟ್ ಆದ್ದರಿಂದ
ಈ ರೀತಿಯ ನಾನು, ಹೋಗಲು ಸಾಕಷ್ಟು ಒಳ್ಳೆಯ ಮನುಷ್ಯ?

158
00:08:26,230 --> 00:08:28,870
ಏನು ಕಾಣೆಯಾಗಿದೆ?

159
00:08:28,870 --> 00:08:31,840
>> ಪ್ರತಿ ಸ್ಟ್ರಿಂಗ್ ನಾವು ಕೆಲಸ ನೆನಪಿಡಿ
ಸಿ backslash ಶೂನ್ಯ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ರಲ್ಲಿ,

160
00:08:31,840 --> 00:08:33,339
ಮತ್ತು ನಾವು ಎರಡೂ ಇಲ್ಲಿ ಎಂದು ಬಿಡಬೇಕಾಗಿ.

161
00:08:33,339 --> 00:08:36,090
ನಾವು ಪಕ್ಕಕ್ಕೆ ಒಂದು ಬೈಟ್ ಹೊಂದಿಸ ಬೇಕಾಗುತ್ತದೆ
ಮೆಮೊರಿಯ ಆದ್ದರಿಂದ ನಾವು ಹಿಡಿದಿಡಲು

162
00:08:36,090 --> 00:08:39,130
ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಗೊಂಡಿದೆ ಯಾವಾಗ.

163
00:08:39,130 --> 00:08:41,049
ಆದ್ದರಿಂದ ಮತ್ತೆ ಈ ವ್ಯವಸ್ಥೆ
ರೀತಿಯಲ್ಲಿ ವಸ್ತುಗಳ

164
00:08:41,049 --> 00:08:42,799
ಮೆಮೊರಿ ಮೈಟ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ
, ಸ್ವಲ್ಪ ಯಾದೃಚ್ಛಿಕ

165
00:08:42,799 --> 00:08:44,870
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಹೇಗೆ
ಅತ್ಯಂತ ವ್ಯವಸ್ಥೆಗಳು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

166
00:08:44,870 --> 00:08:48,330
ಹಲವಾರು ಅವುಗಳನ್ನು ಸಾಲಿನಲ್ಲಿ
ನಾಲ್ಕು, ಕಾರಣಗಳಿಗಾಗಿ

167
00:08:48,330 --> 00:08:50,080
ನಾವು ಅಗತ್ಯವಿಲ್ಲ ಎಂದು
ಇದೀಗ ಬರಲು.

168
00:08:50,080 --> 00:08:53,060
ಈ ಆದ್ದರಿಂದ ಎಂದು ಹೇಳಲು ಇದು ಸಾಕಾಗುತ್ತದೆ
ಕೋಡ್ ಈ ಮೂರು ಸಾಲುಗಳನ್ನು ನಂತರ,

169
00:08:53,060 --> 00:08:54,810
ಈ ಮೆಮೊರಿ ರೀತಿ ಏನೆಲ್ಲಾ ಆಗಿದೆ.

170
00:08:54,810 --> 00:08:58,930
ನಾನು ಸ್ಮರಣೆ ಸ್ಥಳಗಳನ್ನು ಬೇಕಾದರೆ
4, 8, ಮತ್ತು 12, ನನ್ನ ಡೇಟಾ ಹಿಡಿದಿಡಲು

171
00:08:58,930 --> 00:09:01,100
ಈ ನನ್ನ ಮೆಮೊರಿ ರೀತಿ ಏನೆಲ್ಲಾ ಆಗಿದೆ.

172
00:09:01,100 --> 00:09:04,062
>> ಕೇವಲ ವಿಶೇಷವಾಗಿ ಎಂದು
ಇಲ್ಲಿ, ಯಾವಾಗ ನಿಷ್ಠುರ

173
00:09:04,062 --> 00:09:06,020
ನಾವು ಮೆಮೊರಿ ಬಗ್ಗೆ ನೀವು
ವಿಳಾಸವು ಸಾಮಾನ್ಯವಾಗಿ ನಾವು

174
00:09:06,020 --> 00:09:08,390
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಕೇತಗಳು ಬಳಸಿ.

175
00:09:08,390 --> 00:09:12,030
ಆದ್ದರಿಂದ ನಾವು ಈ ಎಲ್ಲಾ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಕೇತಗಳಲ್ಲಿ ದಶಮಾಂಶ ರಿಂದ

176
00:09:12,030 --> 00:09:15,010
ಕೇವಲ ಸಾಮಾನ್ಯವಾಗಿ ಏಕೆಂದರೆ
ಹೇಗೆ ನಾವು ಮೆಮೊರಿ ಸಂಪರ್ಕಿಸಿ.

177
00:09:15,010 --> 00:09:17,880
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಮೂಲಕ 0 ಎಂಬ
19, ನಾವು ಹೊಂದಿಲ್ಲ ಶೂನ್ಯವಾಗಿರುತ್ತದೆ

178
00:09:17,880 --> 00:09:20,340
ಶೂನ್ಯ X1 ಮೂರು ಮೂಲಕ ಕ್ಷ ಶೂನ್ಯ.

179
00:09:20,340 --> 00:09:23,790
ಆ ಮೆಮೊರಿ 20 ಬೈಟ್ಗಳು ಎಂದು ನಾವು
ಅಥವಾ ನಾವು ಈ ಚಿತ್ರದಲ್ಲಿ ನೋಡುತ್ತಿರುವ ಎಂದು

180
00:09:23,790 --> 00:09:25,540
ಇಲ್ಲಿಯೇ.

181
00:09:25,540 --> 00:09:29,310
>> ಆದ್ದರಿಂದ ಎಂದು ರೀತಿಯಲ್ಲಿ ಎಲ್ಲಾ, ಹೊರಡೋಣ
ಎರಡನೇ ಮೆಮೊರಿ ಬಳಕೆಯಿಂದ

182
00:09:29,310 --> 00:09:30,490
ಮತ್ತು ಮತ್ತೆ ಪಾಯಿಂಟರ್ಸ್.

183
00:09:30,490 --> 00:09:32,420
ಇಲ್ಲಿ ಅತ್ಯಂತ ಮುಖ್ಯ
ವಿಷಯ ನೆನಪಿಡುವ

184
00:09:32,420 --> 00:09:34,070
ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿ.

185
00:09:34,070 --> 00:09:36,314
ಒಂದು ಪಾಯಿಂಟರ್ ಏನೂ
ಒಂದು ವಿಳಾಸಕ್ಕೆ ಹೆಚ್ಚು.

186
00:09:36,314 --> 00:09:38,230
ನಾನು ಪುನಃ ಹೇಳುತ್ತೇನೆ
ಇದು ಮುಖ್ಯ ಅಂತ

187
00:09:38,230 --> 00:09:42,730
ಒಂದು ಪಾಯಿಂಟರ್ ಏನೂ
ಒಂದು ವಿಳಾಸಕ್ಕೆ ಹೆಚ್ಚು.

188
00:09:42,730 --> 00:09:47,760
ಪಾಯಿಂಟರ್ಸ್ ಸ್ಥಾನಗಳಿಗೆ ವಿಳಾಸಗಳನ್ನು
ನೆನಪಿಗಾಗಿ ಅಸ್ಥಿರ ವಾಸಿಸುವ.

189
00:09:47,760 --> 00:09:52,590
ಆಶಾದಾಯಕವಾಗಿ ಒಂದು ಆಗುತ್ತದೆ ತಿಳಿದುಕೊಂಡು
ಸುಲಭವಾಗಿ ಸ್ವಲ್ಪ ಅವರೊಂದಿಗೆ ಕೆಲಸ.

190
00:09:52,590 --> 00:09:54,550
ನಾನು ಇನ್ನೊಂದು ವಿಷಯ
ಮಾಡಲು ರೀತಿಯ ಮಾಡುವುದು

191
00:09:54,550 --> 00:09:58,510
ದೃಷ್ಟಿ ಏನು ಪ್ರತಿನಿಧಿಸುವ ಚಿತ್ರಗಳು
ಕೋಡ್ ವಿವಿಧ ಸಾಲುಗಳನ್ನು ನಡೆಯುತ್ತಿದೆ.

192
00:09:58,510 --> 00:10:00,660
ಮತ್ತು ಈ ಒಂದೆರಡು ಮಾಡುತ್ತೇನೆ
ಪಾಯಿಂಟರ್ಸ್ ಬಾರಿ,

193
00:10:00,660 --> 00:10:03,354
ಮತ್ತು ನಾವು ಕ್ರಿಯಾತ್ಮಕ ಬಗ್ಗೆ ಮಾತನಾಡಿ
ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಹಾಗೂ.

194
00:10:03,354 --> 00:10:06,020
ನಾನು ಈ ಚಿತ್ರಗಳು ಎಂದು ಭಾವಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ
ವಿಶೇಷವಾಗಿ ಸಹಾಯವಾಗುತ್ತದೆ.

195
00:10:06,020 --> 00:10:09,540
>> ನಾನು ಉದಾಹರಣೆಗೆ ಹೇಳುತ್ತಾರೆ ಆದ್ದರಿಂದ, ಇಂಟ್ ಕೆ
ನನ್ನ ಕೋಡ್, ಏನು ನಡೆಯುತ್ತಿದೆ?

196
00:10:09,540 --> 00:10:12,524
ವೆಲ್ ಮೂಲತಃ ಏನು ನಡೆಯುತ್ತಿದೆ
ನನ್ನ ಮೀಸಲಿಡಲಾಗಿತ್ತು ಮೆಮೊರಿ ಪಡೆಯುವಲ್ಲಿ ಬಾಗುತ್ತೇನೆ

197
00:10:12,524 --> 00:10:14,690
ಆದರೆ ನಾನು ಬಯಸುವುದಿಲ್ಲ
ನಾನು ಹಾಗೆ ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಿದರೆ

198
00:10:14,690 --> 00:10:16,300
ಒಂದು ಬಾಕ್ಸ್ ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಲು ನಾನು ಇಷ್ಟಪಡುತ್ತೇನೆ.

199
00:10:16,300 --> 00:10:20,090
ನಾನು ಬಾಕ್ಸ್ ಹೊಂದಿವೆ ಮತ್ತು ಇದು ಇಲ್ಲಿದೆ
ಬಣ್ಣದ ಹಸಿರು ನಾನು

200
00:10:20,090 --> 00:10:21,750
ಹಸಿರು ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಪೂರ್ಣಾಂಕಗಳ ಹಾಕಬಹುದು.

201
00:10:21,750 --> 00:10:23,666
ಇದು ಒಂದು ಪಾತ್ರ ನಾನು ಆಗಿದ್ದಲ್ಲಿ
ಒಂದು ನೀಲಿ ಬಾಕ್ಸ್ ಹೊಂದಿರಬಹುದು.

202
00:10:23,666 --> 00:10:27,290
ನಾನು ರಚಿಸುವ ನಾನು ಆದರೆ ನಾನು ಯಾವಾಗಲೂ ಹೇಳುತ್ತಾರೆ
ಪೂರ್ಣಾಂಕಗಳ ಹಿಡಿಸುವ ಬಾಕ್ಸ್

203
00:10:27,290 --> 00:10:28,950
ಬಾಕ್ಸ್ ಹಸಿರು ಬಣ್ಣದಲ್ಲಿರುತ್ತದೆ.

204
00:10:28,950 --> 00:10:33,020
ನಾನು ಶಾಶ್ವತ ಮಾರ್ಕರ್ ತೆಗೆದುಕೊಂಡು
ಮತ್ತು ನಾನು ಬದಿಯಲ್ಲಿ ಕೆ ಬರೆಯಲು.

205
00:10:33,020 --> 00:10:37,590
ಹಾಗಾಗಿ, ಕೆ ಎಂಬ ಬಾಕ್ಸ್
ಇದರೊಳಗೆ ನಾನು ಪೂರ್ಣಾಂಕಗಳ ಹಾಕಬಹುದು.

206
00:10:37,590 --> 00:10:41,070
ನಾನು ಇಂಟ್ ಕೆ ಹೇಳುತ್ತಾರೆ, ಎಂದು ಇಲ್ಲಿದೆ
ಏನು ನನ್ನ ತಲೆಯಲ್ಲಿ ನಡೆಯುತ್ತದೆ.

207
00:10:41,070 --> 00:10:43,140
ನಾನು ಕೆ ಐದು ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಲು ವೇಳೆ, ನಾನು ಏನು ಮಾಡುತ್ತಿದ್ದೇನೆ?

208
00:10:43,140 --> 00:10:45,110
ಸರಿ, ನಾನು ಐದು ಹಾಕುವ ಬಾಗುತ್ತೇನೆ
ಬಾಕ್ಸ್, ಸರಿಯಾದ.

209
00:10:45,110 --> 00:10:48,670
ಈ ವೇಳೆ, ಸಾಕಷ್ಟು ನೇರವಾಗಿರುತ್ತದೆ
ನಾನು ಇಂಟ್ ಕೆ, ಕೆ ಎಂಬ ಬಾಕ್ಸ್ ರಚಿಸಲು ಹೇಳುತ್ತಾರೆ.

210
00:10:48,670 --> 00:10:52,040
ನಾನು, ಕೆ 5 ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಲು
ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಐದು ಪುಟ್.

211
00:10:52,040 --> 00:10:53,865
ಆಶಾದಾಯಕವಾಗಿ ಅಧಿಕ ತುಂಬಾ ಅಲ್ಲ.

212
00:10:53,865 --> 00:10:55,990
ವಿಷಯಗಳನ್ನು ಹೋಗಿ ಅಲ್ಲಿ ಇಲ್ಲಿ
ಆದರೂ ಆಸಕ್ತಿದಾಯಕ ಸ್ವಲ್ಪ.

213
00:10:55,990 --> 00:11:02,590
ನಾನು ಇಂಟ್ * ಎಂಬುದು ಹೇಳಲು ವೇಳೆ, ನಾನು ಮಾಡದಿದ್ದರೂ
ಈ ಅಗತ್ಯವಾಗಿ ರಾಜನಾಥ್,

214
00:11:02,590 --> 00:11:06,150
ಇದು ಸ್ಪಷ್ಟವಾಗಿ ಏನೋ ಅವರಲ್ಲಿದೆ
ಒಂದು ಪೂರ್ಣಾಂಕ ಮಾಡಲು.

215
00:11:06,150 --> 00:11:08,211
ಹಾಗಾಗಿ ಬಣ್ಣ ಪಡೆಯಲಿದ್ದೇನೆ
ಹಸಿರು ರೀತಿಯಲ್ಲಿ ಈ ಬಾಕ್ಸ್

216
00:11:08,211 --> 00:11:10,210
ನಾನು ಏನಾದರೂ ಪಡೆದರು ಗೊತ್ತು
ಒಂದು ಪೂರ್ಣಾಂಕ ಮಾಡಲು,

217
00:11:10,210 --> 00:11:13,400
ಆದರೆ ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಸ್ವತಃ ಅಲ್ಲ,
ಒಂದು ಇಂಟ್ ಸ್ಟಾರ್ ಏಕೆಂದರೆ.

218
00:11:13,400 --> 00:11:15,390
ಏನೋ ಸ್ವಲ್ಪ ಇಲ್ಲ
ಅದರ ಬಗ್ಗೆ ಬೇರೆ.

219
00:11:15,390 --> 00:11:17,620
ಆದ್ದರಿಂದ ಒಂದು ಪೂರ್ಣಾಂಕ ನ ಒಳಗೊಂಡಿರುವ,
ಇಲ್ಲದಿದ್ದರೆ ಅದು ಇಲ್ಲಿದೆ

220
00:11:17,620 --> 00:11:19,830
ತುಂಬಾ ವಿಭಿನ್ನ ಅಲ್ಲ
ನಾವು ಬಗ್ಗೆ ಮಾಡಲಾಯಿತು.

221
00:11:19,830 --> 00:11:24,240
ಇದು ಒಂದು ಬಾಕ್ಸ್, ಅದರ ಲೇಬಲ್ ಸಿಕ್ಕಿತು
ಇದು ಒಂದು ಲೇಬಲ್ ಎಂಬುದು ಧರಿಸಿ,

222
00:11:24,240 --> 00:11:27,280
ಮತ್ತು ಇದು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಇಲ್ಲಿದೆ
ಆ ಯಾವುದೇ ಇಂಟ್ ನಕ್ಷತ್ರಗಳು,.

223
00:11:27,280 --> 00:11:29,894
ಅವರು ಮಾಡಲು ಏನಾದರೂ
ಪೂರ್ಣಾಂಕಗಳ, ಸ್ಪಷ್ಟವಾಗಿ.

224
00:11:29,894 --> 00:11:31,060
ಇಲ್ಲಿ ಕೊನೆಯ ಸಾಲು ಆದರೂ ಇಲ್ಲಿದೆ.

225
00:11:31,060 --> 00:11:37,650
ನಾನು ಹೇಳಲು ವೇಳೆ ಬಿಟ್ಟು = & ಕ್, ವಾಹ್,
ಏನು ಸರಿಯಾದ, ಏನಾಯಿತು?

226
00:11:37,650 --> 00:11:41,820
ಆದ್ದರಿಂದ ಈ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ, ತೋರಿಕೆಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ
ಹಲವಾರು ಬಾಕ್ಸ್ ಎಸೆಯಲಾಯಿತು ಸಿಗುತ್ತದೆ.

227
00:11:41,820 --> 00:11:44,930
ಎಂದು ಎಲ್ಲಾ, ಪಿ.ಕೆ. ಆಗಿದೆ
ಕೆ ವಿಳಾಸವನ್ನು ಪಡೆಯುತ್ತದೆ.

228
00:11:44,930 --> 00:11:52,867
ಕೆ ಮೆಮೊರಿ ವಾಸಿಸುತ್ತಾರೆ ಅಲ್ಲಿ ಹಾಗಾಗಿ ಅಂಟದಂತೆ ನಾನು,
ಅದರ ವಿಳಾಸ, ಅದರ ಬೈಟ್ಗಳು ವಿಳಾಸಕ್ಕೆ.

229
00:11:52,867 --> 00:11:55,200
ನಾನು ಮಾಡುತ್ತಿರುವೆ ಎಲ್ಲಾ ನಾನು ಹೇಳುವ ನನಗೆ
ಮೌಲ್ಯವನ್ನು ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಏನು

230
00:11:55,200 --> 00:11:59,430
ನನ್ನ ಬಾಕ್ಸ್ ಎಂಬ ಪಿ.ಕೆ. ಒಳಗೆ ಹಾಕಲು.

231
00:11:59,430 --> 00:12:02,080
ಇವುಗಳನ್ನು ಏಕೆಂದರೆ
ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಕಾಣುವ ಕಾರಣ

232
00:12:02,080 --> 00:12:04,955
ಶೂನ್ಯ X ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್
ಎಂಟು ಶೂನ್ಯ ಸಿ ಏಳು ನಾಲ್ಕು ಎಂಟು

233
00:12:04,955 --> 00:12:07,790
ಎರಡು ಶೂನ್ಯ ಕಾರಣವಿರಬಹುದು
ತುಂಬಾ ಅರ್ಥಪೂರ್ಣ ಅಲ್ಲ.

234
00:12:07,790 --> 00:12:12,390
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ದೃಶ್ಯೀಕರಿಸುವುದು ಮಾಡಿದಾಗ,
ನಾವು ವಾಸ್ತವವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಹಾಗೆ.

235
00:12:12,390 --> 00:12:17,000
ಪಿ.ಕೆ. ನಮಗೆ ಮಾಹಿತಿ ನೀಡುತ್ತದೆ
ನಾವು ನೆನಪಿಗಾಗಿ ಕೆ ಕಂಡುಹಿಡಿಯಬೇಕು.

236
00:12:17,000 --> 00:12:19,120
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಎಂಬುದು ಇದು ಬಾಣ ಹೊಂದಿದೆ.

237
00:12:19,120 --> 00:12:21,670
ನಾವು ಉದ್ದದ ವೇಳೆ
ಆ ಬಾಣದ ಕಲ್ಪನೆಯ

238
00:12:21,670 --> 00:12:25,280
ನೀವು ಮೇಲೆ ನಡೆದು ವಿಷಯ, ನಾವು ವೇಳೆ
ಬಾಣದ ಉದ್ದ ಬಲ್ಲವು,

239
00:12:25,280 --> 00:12:29,490
ಆ ಬಾಣದ ಅತ್ಯಂತ ತುದಿಯಲ್ಲಿ, ನಾವು
ನೆನಪಿಗಾಗಿ ಸ್ಥಳ ಕಾಣಬಹುದು

240
00:12:29,490 --> 00:12:31,390
ಇಲ್ಲಿ k ವಾಸಿಸುತ್ತಾರೆ.

241
00:12:31,390 --> 00:12:34,360
ಮತ್ತು ನಿಜಕ್ಕೂ ಪ್ರಮುಖ
ಕೆ ವಾಸಿಸುತ್ತಾರೆ ಅಲ್ಲಿ ನಾವು ತಿಳಿಯಲು ಒಮ್ಮೆ ಏಕೆಂದರೆ,

242
00:12:34,360 --> 00:12:37,870
ನಾವು ದಶಮಾಂಶ ಕೆಲಸ ಪ್ರಾರಂಭಿಸುತ್ತಾರೆ
ಮೆಮೊರಿ ಸ್ಥಳ ಒಳಗೆ.

243
00:12:37,870 --> 00:12:40,780
ನಾವು ಒಂದು ಚಿಕ್ಕ ಬರುತ್ತಿದೆ ಆದರೂ
ಈಗ ಮುಂದೆ ನಮ್ಮದೇ ಬಿಟ್.

244
00:12:40,780 --> 00:12:42,240
>> ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಏನು?

245
00:12:42,240 --> 00:12:45,590
ಒಂದು ಪಾಯಿಂಟರ್ ಅವರ ಒಂದು ಡೇಟಾ ವಸ್ತುವಿಗಾಗಿ ಆಗಿದೆ
ಮೌಲ್ಯ ಒಂದು ಮೆಮೊರಿ ವಿಳಾಸ.

246
00:12:45,590 --> 00:12:49,740
ಎಂದು ಶೂನ್ಯ ಎಕ್ಸ್ ಎಂಟು ಶೂನ್ಯ ಸ್ಟಫ್
ಇಂದಿನ, ಒಂದು ಮೆಮೊರಿ ಸ್ಥಳವಾಗಿದೆ.

247
00:12:49,740 --> 00:12:52,060
ಎಂದು ಮೆಮೊರಿ ಒಂದು ಸ್ಥಳವೆನಿಸಿದೆ.

248
00:12:52,060 --> 00:12:55,080
ಮತ್ತು ಒಂದು ಪಾಯಿಂಟರ್ ಮಾದರಿ
ರೀತಿಯ ವಿವರಿಸುತ್ತದೆ

249
00:12:55,080 --> 00:12:56,930
ದತ್ತಾಂಶದ ನೀವು ಕಾಣುವಿರಿ
ಆ ಮೆಮೊರಿ ವಿಳಾಸ.

250
00:12:56,930 --> 00:12:58,810
ಆದ್ದರಿಂದ ಇಂಟ್ ಸ್ಟಾರ್ ಭಾಗವಾಗಿ ಸರಿ ಇಲ್ಲ.

251
00:12:58,810 --> 00:13:03,690
ನಾನು ಬಾಣದ ಅನುಸರಿಸಲು, ಅದು ಇಲ್ಲಿದೆ
ಒಂದು ಸ್ಥಳ ನನಗೆ ದಾರಿ ಹೋಗುವ.

252
00:13:03,690 --> 00:13:06,980
ಆ ಸ್ಥಳ, ನಾನು
ನನ್ನ ಉದಾಹರಣೆಯಲ್ಲಿ ಅಲ್ಲಿ ಕಾಣಬಹುದು,

253
00:13:06,980 --> 00:13:08,240
ಹಸಿರು ಬಣ್ಣದ ಬಾಕ್ಸ್ ಆಗಿದೆ.

254
00:13:08,240 --> 00:13:12,650
ಅದು ಇಲ್ಲಿದೆ, ಒಂದು ಪೂರ್ಣಾಂಕ ನಾನು
ನಾನು ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ವೇಳೆ ಕಾಣಬಹುದು.

255
00:13:12,650 --> 00:13:14,830
ಒಂದು ಆಫ್ ಡೇಟಾ ಪ್ರಕಾರ
ಪಾಯಿಂಟರ್ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ

256
00:13:14,830 --> 00:13:17,936
ಆ ಮೆಮೊರಿ ವಿಳಾಸದಲ್ಲಿ ಕಾಣಬಹುದು.

257
00:13:17,936 --> 00:13:19,560
ಇಲ್ಲಿ ಆದರೂ ನಿಜವಾಗಿಯೂ ತಂಪಾದ ವಿಷಯ.

258
00:13:19,560 --> 00:13:25,090
ಪಾಯಿಂಟರ್ಸ್ ನಮಗೆ ಸಂಚರಿಸಲು ಅವಕಾಶ
ಕಾರ್ಯಗಳನ್ನು ನಡುವೆ ಅಸ್ಥಿರ.

259
00:13:25,090 --> 00:13:28,520
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಅಸ್ಥಿರ ಪಾಸ್
ಮತ್ತು ಅವುಗಳನ್ನು ನಕಲು ರವಾನಿಸುವುದಿಲ್ಲ.

260
00:13:28,520 --> 00:13:32,879
ನಾವು ತಿಳಿದಿದ್ದರೆ ಏಕೆಂದರೆ ನಿಖರವಾಗಿ ಅಲ್ಲಿ
ಮೆಮೊರಿ ಒಂದು ವೇರಿಯೇಬಲ್ ಹುಡುಕಲು,

261
00:13:32,879 --> 00:13:35,670
ನಾವು ಪ್ರತಿಯನ್ನು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ
ಇದು, ನಾವು ಆ ಸ್ಥಳ ಹೋಗಿ

262
00:13:35,670 --> 00:13:37,844
ಮತ್ತು ವೇರಿಯಬಲ್ ಕೆಲಸ.

263
00:13:37,844 --> 00:13:40,260
ಮೂಲಭೂತವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಆದ್ದರಿಂದ ರೀತಿಯ
ಒಂದು ಕಂಪ್ಯೂಟರ್ ಪರಿಸರದಲ್ಲಿ ಮಾಡಲು

264
00:13:40,260 --> 00:13:42,360
ಬಹಳ ನೈಜ ರೀತಿಯಲ್ಲಿ, ಸರಿಯಾದ.

265
00:13:42,360 --> 00:13:44,640
>> ಇಲ್ಲಿ ಸಾದೃಶ್ಯ ಇಲ್ಲಿದೆ.

266
00:13:44,640 --> 00:13:48,080
ನಾನು ನೋಟ್ಬುಕ್ ಎಂದು ಅವಕಾಶ,
ಬಲ, ಮತ್ತು ಇದು ಟಿಪ್ಪಣಿಗಳು ಸಂಪೂರ್ಣ.

267
00:13:48,080 --> 00:13:50,230
ನಾನು ನೀವು ಅಪ್ಡೇಟ್ ಬಯಸುತ್ತೇನೆ.

268
00:13:50,230 --> 00:13:53,960
ನೀವು ಕಾರ್ಯಗಳಾಗಿವೆ ಎಂದು
ನವೀಕರಣಗಳನ್ನು ಟಿಪ್ಪಣಿಗಳು, ಬಲ.

269
00:13:53,960 --> 00:13:56,390
ರೀತಿಯಲ್ಲಿ ನಾವು ಇಲ್ಲಿಗೆ
ಇದುವರೆಗೆ ಕೆಲಸ, ಏನು

270
00:13:56,390 --> 00:14:02,370
ನೀವು ನನ್ನ ಪುಸ್ತಕದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಇದೆ ನಡೆಯುತ್ತದೆ,
ನೀವು ಪ್ರತಿಯನ್ನು ಸಂಗ್ರಹ ಮಾಡುವುದಕ್ಕೆ ಹೋಗುತ್ತೇನೆ

271
00:14:02,370 --> 00:14:06,410
ನೀವು ಒಂದು ಜೆರಾಕ್ಸ್ ಪ್ರತಿಯನ್ನು ಮಾಡಿಕೊಳ್ಳುವಿರಿ
ನೋಟ್ಬುಕ್ ಪ್ರತಿ ಪುಟ.

272
00:14:06,410 --> 00:14:09,790
ನೀವು ನನ್ನ ನೋಟ್ಬುಕ್ ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ
ನನ್ನ ಮೇಜಿನ ಮೇಲೆ ನೀವು ಪೂರೈಸಿದಾಗ,

273
00:14:09,790 --> 00:14:14,600
ನೀವು ಹೋಗಿ ವಸ್ತುಗಳನ್ನು ಔಟ್ ದಾಟಲು ಮಾಡುತ್ತೇವೆ ನನ್ನ
ದಿನಾಂಕ ಅಥವಾ ತಪ್ಪು ಔಟ್ ಎಂದು ನೋಟ್ಬುಕ್,

274
00:14:14,600 --> 00:14:19,280
ಮತ್ತು ನಂತರ ನೀವು ಮತ್ತೆ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ
ನನಗೆ ಜೆರಾಕ್ಸ್ ಪುಟಗಳ ಸ್ಟಾಕ್

275
00:14:19,280 --> 00:14:22,850
ನನ್ನ ನೋಟ್ಬುಕ್ ಪ್ರತಿಕೃತಿಯ ಜೊತೆ ಆಗಿದೆ
ನೀವು ಮಾಡಿದ ಬದಲಾವಣೆಗಳನ್ನು.

276
00:14:22,850 --> 00:14:27,040
ಮತ್ತು ಆ ಸಮಯದಲ್ಲಿ, ಇದು ನನಗೆ ಬಿಟ್ಟಿದ್ದು
ಕರೆ ಕಾರ್ಯದಲ್ಲಿ, ಕಾಲರ್,

277
00:14:27,040 --> 00:14:30,582
ನಿಮ್ಮ ಟಿಪ್ಪಣಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ಧರಿಸುವ ಮತ್ತು
ನನ್ನ ಪುಸ್ತಕದಲ್ಲಿ ಅವುಗಳನ್ನು ಮತ್ತೆ ಒಂದುಗೂಡಿಸಲು.

278
00:14:30,582 --> 00:14:32,540
ಆದ್ದರಿಂದ ಹಂತಗಳು ಬಹಳಷ್ಟು ಇಲ್ಲ
ಇಲ್ಲಿ ಒಳಗೊಂಡಿರುವ, ಬಲ.

279
00:14:32,540 --> 00:14:34,850
ಲೈಕ್ ಇದು ಉತ್ತಮ ಎಂದು
ನಾನು ಹೇಳಲು ವೇಳೆ, ಹೇ, ನೀವು

280
00:14:34,850 --> 00:14:38,370
ನನ್ನ ನೋಟ್ಬುಕ್ ಅಪ್ಡೇಟ್
ನನಗೆ, ನನ್ನ ನೋಟ್ಬುಕ್ ಹ್ಯಾಂಡ್

281
00:14:38,370 --> 00:14:40,440
ಮತ್ತು ನೀವು ವಿಷಯಗಳನ್ನು ತೆಗೆದುಕೊಂಡು
ಅಕ್ಷರಶಃ ಅವುಗಳನ್ನು ದಾಟಲು

282
00:14:40,440 --> 00:14:42,810
ಮತ್ತು ನನ್ನ ಪುಸ್ತಕದಲ್ಲಿ ನನ್ನ ಟಿಪ್ಪಣಿಗಳು ನವೀಕರಿಸಿ.

283
00:14:42,810 --> 00:14:45,140
ತದನಂತರ ನನ್ನ ನೋಟ್ಬುಕ್ ಮತ್ತೆ ನೀಡಿ.

284
00:14:45,140 --> 00:14:47,320
ಆ ರೀತಿಯ ಯಾವ
ಪಾಯಿಂಟರ್ಸ್, ಹಾಗೆ ಮಾಡಲು ಅವಕಾಶ

285
00:14:47,320 --> 00:14:51,320
ಅವರು ಈ ಪರಿಸರದಲ್ಲಿ ಬಹಳಷ್ಟು
ನಾವು ವಾಸ್ತವದಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಹೆಚ್ಚು.

286
00:14:51,320 --> 00:14:54,640
>> ಆದ್ದರಿಂದ ಸರಿ ಇಲ್ಲಿದೆ
ಒಂದು ಪಾಯಿಂಟರ್, ನ ಮಾತನಾಡೋಣ ಇದೆ

287
00:14:54,640 --> 00:14:58,040
ಪಾಯಿಂಟರ್ಸ್ ಸಿ ಕೆಲಸ, ಮತ್ತು ಬಗ್ಗೆ
ಹೇಗೆ ನಾವು ಅವರೊಂದಿಗೆ ಕೆಲಸ ಆರಂಭಿಸಬಹುದು.

288
00:14:58,040 --> 00:15:02,550
ಆದ್ದರಿಂದ ಒಂದು ಸರಳ ಪಾಯಿಂಟರ್ ಇಲ್ಲ
ಸಿ ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಎಂಬ.

289
00:15:02,550 --> 00:15:04,830
ಏನೂ ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಅಂಕಗಳನ್ನು.

290
00:15:04,830 --> 00:15:08,310
ಇದು ಆದಂತೆ ಬಹುಶಃ ತೋರುತ್ತದೆ
ವಾಸ್ತವವಾಗಿ ಬಹಳ ಉಪಯುಕ್ತ ವಿಷಯ,

291
00:15:08,310 --> 00:15:10,500
ಆದರೆ ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು
ನಂತರ ಸ್ವಲ್ಪ, ವಾಸ್ತವವಾಗಿ

292
00:15:10,500 --> 00:15:15,410
ಈ ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಸೂಕ್ತ ರಲ್ಲಿ ಬರಬಹುದು.

293
00:15:15,410 --> 00:15:19,090
ಮತ್ತು ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸಲು ಬಂದ, ಮತ್ತು
ನೀವು ಅದರ ಮೌಲ್ಯವನ್ನು immediately- ಸೆಟ್ ಇಲ್ಲ

294
00:15:19,090 --> 00:15:21,060
ಸ್ಥಾಪನೆಗೆ ಒಂದು ಉದಾಹರಣೆ
ಅದರ ಮೌಲ್ಯವನ್ನು ತಕ್ಷಣ

295
00:15:21,060 --> 00:15:25,401
ಮತ್ತೆ ಒಂದೆರಡು ಸ್ಲೈಡ್ಗಳು ಇರುತ್ತದೆ
ನಾನು ಎಂಬುದು & ಕ್ ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಿದರು ಅಲ್ಲಿ

296
00:15:25,401 --> 00:15:28,740
ಪಿ.ಕೆ. ಎಂದು, ಕೆ ವಿಳಾಸ ಪಡೆಯುತ್ತದೆ
ನಾವು, ಅಂದರೆ ಏನು ನೋಡುತ್ತಾರೆ

297
00:15:28,740 --> 00:15:32,990
ನಾವು ಕೋಡ್ ಹೇಗೆ ನೋಡುತ್ತಾರೆ shortly-
ನಾವು ಏನೋ ಇದರ ಬೆಲೆಯ ಸೆಟ್ ಇದ್ದರೆ

298
00:15:32,990 --> 00:15:35,380
ತಕ್ಷಣ ಅರ್ಥಪೂರ್ಣ,
ನೀವು ಯಾವಾಗಲೂ ಮಾಡಬೇಕು

299
00:15:35,380 --> 00:15:37,480
ಶೂನ್ಯ ತೋರಿಸಲು ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಸೆಟ್.

300
00:15:37,480 --> 00:15:40,260
ನೀವು ಏನೂ ತೋರಿಸಲು ಸೆಟ್ ಮಾಡಬೇಕು.

301
00:15:40,260 --> 00:15:43,614
>> ಆ ಅತ್ಯಂತ ವಿಭಿನ್ನವಾಗಿದೆ
ಇದು ಕೇವಲ ಮೌಲ್ಯ ಬಿಟ್ಟು

302
00:15:43,614 --> 00:15:45,530
ಮತ್ತು ನಂತರ ಒಂದು ಘೋಷಿಸುವ
ಪಾಯಿಂಟರ್ ಮತ್ತು ಕೇವಲ ಊಹಿಸಿಕೊಂಡು

303
00:15:45,530 --> 00:15:48,042
ಅಪರೂಪವಾಗಿ ನಿಜವಾದ ಏಕೆಂದರೆ ಶೂನ್ಯ.

304
00:15:48,042 --> 00:15:50,000
ಆದ್ದರಿಂದ ನೀವು ಯಾವಾಗಲೂ ಹೊಂದಿಸಬೇಕು
ಒಂದು ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು

305
00:15:50,000 --> 00:15:55,690
ನೀವು ಅದರ ಮೌಲ್ಯವನ್ನು ಸೆಟ್ ಇದ್ದರೆ ಶೂನ್ಯ
ತಕ್ಷಣ ಅರ್ಥಪೂರ್ಣ ಏನೋ.

306
00:15:55,690 --> 00:15:59,090
ನೀವು ನಾಟ್ ಪರೀಕ್ಷಿಸಬಹುದು ಒಂದು ಪಾಯಿಂಟರ್ ಮೌಲ್ಯದ ಎಂದು
ಸಮಾನತೆ ಆಯೋಜಕರು ಬಳಸಿಕೊಂಡು ಶೂನ್ಯ

307
00:15:59,090 --> 00:16:05,450
(==), ಕೇವಲ ನೀವು ಯಾವುದೇ ಪೂರ್ಣಾಂಕ ಹೋಲಿಸಿ ಇಷ್ಟ
ಮೌಲ್ಯಗಳನ್ನು ಅಥವಾ ಪಾತ್ರ ಮೌಲ್ಯಗಳು ಬಳಸಿಕೊಂಡು (==)

308
00:16:05,450 --> 00:16:06,320
ಜೊತೆಗೆ.

309
00:16:06,320 --> 00:16:10,994
ಇದು ನಿರಂತರ ವಿಶೇಷ ರೀತಿಯ ಇಲ್ಲಿದೆ
ನೀವು ಪರೀಕ್ಷಿಸಲು ಬಳಸಬಹುದಾಗಿದೆ ಮೌಲ್ಯವನ್ನು.

310
00:16:10,994 --> 00:16:13,160
ಆದ್ದರಿಂದ ಬಹಳ ಸರಳವಾಗಿತ್ತು
ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ಪಾಯಿಂಟರ್.

311
00:16:13,160 --> 00:16:15,320
ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ ರಚಿಸಲು
ಒಂದು ಪಾಯಿಂಟರ್ ಹೊರತೆಗೆಯಲು ಆಗಿದೆ

312
00:16:15,320 --> 00:16:18,240
ಒಂದು ವೇರಿಯಬಲ್ ವಿಳಾಸ
ನೀವು ಈಗಾಗಲೇ ರಚಿಸಿದ,

313
00:16:18,240 --> 00:16:22,330
ಮತ್ತು ನೀವು ಈ ಬಳಸಿ
ಆಯೋಜಕರು ವಿಳಾಸ ಹೊರತೆಗೆಯುವಿಕೆ.

314
00:16:22,330 --> 00:16:26,720
ಇದು ನಾವು ಈಗಾಗಲೇ ಹಿಂದೆ ನೋಡಿದ
ಮೊದಲ ಚಿತ್ರದಲ್ಲಿ ಉದಾಹರಣೆಗೆ ನಾನು ತೋರಿಸಿದರು.

315
00:16:26,720 --> 00:16:31,450
ಎಕ್ಸ್ ನಾವು ಮಾಡಿದ ಒಂದು ವ್ಯತ್ಯಯ ಆದ್ದರಿಂದ
ಈಗಾಗಲೇ ರೀತಿಯ ಪೂರ್ಣಾಂಕ ದಾಖಲಿಸಿದವರು,

316
00:16:31,450 --> 00:16:35,110
ನಂತರ & X ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಸೂಚಿಯಾಗಿದೆ.

317
00:16:35,110 --> 00:16:39,810
& X ಸಮೀಕರಣವು-, & ಹೊರತೆಗೆಯಲು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ
ಬಲಭಾಗದಲ್ಲಿ ವಿಷಯ ವಿಳಾಸ.

318
00:16:39,810 --> 00:16:45,350
ಮತ್ತು ಒಂದು ಪಾಯಿಂಟರ್ ಕೇವಲ ಒಂದು ವಿಳಾಸ ರಿಂದ
ಹೆಚ್ಚು & X ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಪಾಯಿಂಟರ್

319
00:16:45,350 --> 00:16:48,560
ಇದರ ಮೌಲ್ಯ ಅಲ್ಲಿ ಮೆಮೊರಿ ಎಕ್ಸ್ ಜೀವನದಲ್ಲಿ.

320
00:16:48,560 --> 00:16:50,460
ಇದು ಎಕ್ಸ್ ವಿಳಾಸ ಇಲ್ಲಿದೆ.

321
00:16:50,460 --> 00:16:53,296
ಆದ್ದರಿಂದ & X ಎಕ್ಸ್ ವಿಳಾಸ.

322
00:16:53,296 --> 00:16:55,670
ಈ ಒಂದು ಹೆಜ್ಜೆ ಮುಂದೆ ನೋಡೋಣ
ಮತ್ತಷ್ಟು ಮತ್ತು ಏನೋ ಸಂಪರ್ಕ

323
00:16:55,670 --> 00:16:58,380
ನಾನು ಮೊದಲು ವಿಡಿಯೋದಲ್ಲಿ ಪ್ರಸ್ತಾಪಿಸುತ್ತಾನೆ.

324
00:16:58,380 --> 00:17:06,730
ಆಗ ಡಬಲ್ಸ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಂತರ, ವೇಳೆ
& ಆಗ ಚದರ ಬ್ರಾಕೆಟ್ ನಾನು ಒಂದು ಪಾಯಿಂಟರ್

325
00:17:06,730 --> 00:17:08,109
ಎರಡು ಗೆ.

326
00:17:08,109 --> 00:17:08,970
ಸರಿ.

327
00:17:08,970 --> 00:17:12,160
ನಾನು ವೇಳೆ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಆಗ
ಆಗ, ಡಬಲ್ಸ್ ಒಂದು ರಚನೆ

328
00:17:12,160 --> 00:17:19,069
ನಂತರ ನಾನು ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಆಗ
ವ್ಯೂಹ ನ I- ನೇ ಅಂಶ

329
00:17:19,069 --> 00:17:29,270
ಮತ್ತು & ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಆಗ ನಾನು ಅಲ್ಲಿ ಆಗಿದೆ
ಮೆಮೊರಿ ಆಗ ನ I- ನೇ ಅಂಶ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

330
00:17:29,270 --> 00:17:31,790
>> ಇಲ್ಲಿ ಗೋಜಲನ್ನು ಇಲ್ಲಿದೆ?

331
00:17:31,790 --> 00:17:34,570
ಒಂದು ರಚನೆಗಳು ಹೆಸರು, ಗೋಜಲನ್ನು
ಈ ಇಡೀ ವಿಷಯ,

332
00:17:34,570 --> 00:17:39,290
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೆಸರು ಎಂದು
ವಾಸ್ತವವಾಗಿ ಸ್ವತಃ ಒಂದು ಪಾಯಿಂಟರ್.

333
00:17:39,290 --> 00:17:41,170
ನೀವು ಕೆಲಸ ಬಂದಿದೆ
ಎಲ್ಲಾ ಸೇರಿ ಪಾಯಿಂಟರ್ಸ್

334
00:17:41,170 --> 00:17:45,290
ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಪ್ರತಿ ಬಾರಿ.

335
00:17:45,290 --> 00:17:49,090
ಉದಾಹರಣೆಗೆ ನೆನಪು
ವೇರಿಯಬಲ್ ವ್ಯಾಪ್ತಿ ಮೇಲೆ,

336
00:17:49,090 --> 00:17:53,420
ನಾನು ಪ್ರಸ್ತುತ ವೀಡಿಯೊ ಕೊನೆಯಲ್ಲಿ
ನಾವು ಒಂದು ಕಾರ್ಯ ಅಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ

337
00:17:53,420 --> 00:17:56,890
ಎಂಬ ಸೆಟ್ ಇಂಟ್ ಮತ್ತು
ಕಾರ್ಯ ಸೆಟ್ ಶ್ರೇಣಿಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

338
00:17:56,890 --> 00:18:00,490
ನಿಮ್ಮ ಸವಾಲು ನಿರ್ಧರಿಸಲು
ಇಲ್ಲದಿರಲಿ ಅಥವಾ

339
00:18:00,490 --> 00:18:03,220
ನಾವು ಮುದ್ರಿತ ಮೌಲ್ಯಗಳು
ಕ್ರಿಯೆಯ ಕೊನೆಯಲ್ಲಿ,

340
00:18:03,220 --> 00:18:05,960
ಮುಖ್ಯ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ.

341
00:18:05,960 --> 00:18:08,740
>> ನೀವು ಉದಾಹರಣೆಗೆ ಕರೆಸಿಕೊಳ್ಳುವುದು ವೇಳೆ
ಅಥವಾ ನೀವು ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದರು ಮಾಡಿದ ವೇಳೆ,

342
00:18:08,740 --> 00:18:13,080
ನಿಮಗೆ ಕರೆ you- ಮಾಡಿದಾಗ ತಿಳಿದಿದೆ
ಸೆಟ್ ಇಂಟ್ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

343
00:18:13,080 --> 00:18:16,390
ಆದರೆ ಕರೆ ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತದೆ ಹೊಂದಿಸಲು.

344
00:18:16,390 --> 00:18:19,280
ಮತ್ತು ನಾನು ರೀತಿಯ ಏಕೆ ಮೇಲೆ glossed
ಆ ಸಮಯದಲ್ಲಿ ಪ್ರಕರಣವಾಗಿತ್ತು.

345
00:18:19,280 --> 00:18:22,363
ನಾನು ಅದನ್ನು, ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಹೇಳಿದರು
ವಿಶೇಷ, ನಿಮಗೆ ತಿಳಿದಿರುವ, ಒಂದು ಕಾರಣಗಳಿವೆ.

346
00:18:22,363 --> 00:18:25,020
ಕಾರಣ ಒಂದು ರಚನೆಯ ಆಗಿದೆ
ಹೆಸರು ನಿಜವಾಗಿಯೂ ಒಂದು ಪಾಯಿಂಟರ್

347
00:18:25,020 --> 00:18:28,740
ಮತ್ತು ಈ ವಿಶೇಷ ಇಲ್ಲ
ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಎಂದು

348
00:18:28,740 --> 00:18:30,510
ಕೆಲಸ ವಿಷಯಗಳನ್ನು ಬಹಳ ಒಳ್ಳೆಯದೆಂದು ಮಾಡಲು.

349
00:18:30,510 --> 00:18:34,410
ಅವರು ಒಂದು ಕಲ್ಪನೆಯನ್ನು ಮಾಡಲು
ಬಹಳಷ್ಟು ಕಡಿಮೆ ಬೆದರಿಸುವ ಪಾಯಿಂಟರ್

350
00:18:34,410 --> 00:18:36,800
ಅವರು ರೀತಿಯ ಆರ್ ಮತ್ತು ಇಲ್ಲಿದೆ
ಆ ರೀತಿಯಲ್ಲಿ ಪ್ರಸ್ತುತ.

351
00:18:36,800 --> 00:18:38,600
ಆದರೆ ನಿಜವಾಗಿಯೂ ಸಾಲುಗಳು ಪಾಯಿಂಟರ್ಸ್ ಇವೆ.

352
00:18:38,600 --> 00:18:41,580
ಮತ್ತು ಏಕೆ ನಾವು
ಅರೇ ಒಂದು ಬದಲಾವಣೆ ಮಾಡಿದ್ದಾರೆ

353
00:18:41,580 --> 00:18:44,880
ನಾವು ಒಂದು ನಿಯತಾಂಕ ಒಂದು ರಚನೆಯ ಹೋದಾಗ
ಒಂದು ಕಾರ್ಯ ಅಥವಾ ವಾದವನ್ನು

354
00:18:44,880 --> 00:18:50,110
ರಚನೆಯ ಒಂದು ಕಾರ್ಯ, ್ಷೀಸಿ
ವಾಸ್ತವವಾಗಿ ಎರಡೂ callee ಬದಲಾಗಿದೆ

355
00:18:50,110 --> 00:18:51,160
ಮತ್ತು ಕಾಲರ್ ನಲ್ಲಿ.

356
00:18:51,160 --> 00:18:55,846
ಪ್ರತಿ ರೀತಿಯ ಇದು
ನಾವು ನೋಡಿದ ವೇರಿಯಬಲ್ ಅಲ್ಲ.

357
00:18:55,846 --> 00:18:58,970
ಆದ್ದರಿಂದ ಇರಿಸಿಕೊಳ್ಳಲು ವಿಷಯ
ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ಮಾಡಿದಾಗ ಮನಸ್ಸಿಗೆ,

358
00:18:58,970 --> 00:19:01,610
ಎಂದು ಹೆಸರು
ಶ್ರೇಣಿಯನ್ನು ವಾಸ್ತವವಾಗಿ ಒಂದು ಪಾಯಿಂಟರ್

359
00:19:01,610 --> 00:19:04,750
ರಚನೆಯ ಮೊದಲ ಅಂಶ.

360
00:19:04,750 --> 00:19:08,930
>> ಸರಿ ಈಗ ನಾವು ಈ ಎಲ್ಲಾ ಹೊಂದಿವೆ
ಸತ್ಯ, ನ ಬಲ, ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಅವಕಾಶ.

361
00:19:08,930 --> 00:19:11,370
ನಾವು ಬಗ್ಗೆ ಕಾಳಜಿ
ಅಲ್ಲಿ ಏನೋ ವಾಸಿಸುತ್ತಾರೆ.

362
00:19:11,370 --> 00:19:14,120
ನಾನು ಹೇಳಿದರು ಸರಿ ಇದೂ ಸಾಕಷ್ಟು ಇಲ್ಲಿದೆ
ಏನೋ ವಾಸಿಸುತ್ತಾರೆ ಅಲ್ಲಿ ತಿಳಿಯಲು ಉಪಯುಕ್ತ

363
00:19:14,120 --> 00:19:17,240
ಆದ್ದರಿಂದ ನೀವು ಹೋಗಿ ಅದನ್ನು ಬದಲಾಯಿಸಬಹುದು.

364
00:19:17,240 --> 00:19:19,390
ಇದು ಕೆಲಸ ಮತ್ತು ವಾಸ್ತವವಾಗಿ
ವಿಷಯ ಎಂದು ನೀವು

365
00:19:19,390 --> 00:19:23,710
ವೇರಿಯಬಲ್ ಕಾರ್ಯಗತವಾಗುತ್ತವೆ ಮಾಡಲು ಬಯಸುವ,
ಮತ್ತು ಇದು ಕೆಲವು ಪ್ರತಿಗೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

366
00:19:23,710 --> 00:19:26,150
ಈ dereferencing ಕರೆಯಲಾಗುತ್ತದೆ.

367
00:19:26,150 --> 00:19:28,690
ನಾವು ಉಲ್ಲೇಖ ಹೋಗಿ
ನಾವು ಅಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದು.

368
00:19:28,690 --> 00:19:32,660
ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು ಆದ್ದರಿಂದ ಇದನ್ನು
ಪಿಸಿ, ಮತ್ತು ಇದು ಒಂದು ಪಾತ್ರ ಸೂಚಿತವಾಗಿರುತ್ತದೆ,

369
00:19:32,660 --> 00:19:40,610
ನಂತರ ನಾವು * ಪಿಸಿ ಮತ್ತು * ಪಿಸಿ ಹೇಳಬಹುದು
ನಾವು ಹೋಗಿ ನಾವು ಕಾಣುವಿರಿ ಹೆಸರು

370
00:19:40,610 --> 00:19:42,910
ವಿಳಾಸ ಪಿಸಿ.

371
00:19:42,910 --> 00:19:47,860
ನಾವು ಕಾಣುವಿರಿ ಒಂದು ಪಾತ್ರ ಮತ್ತು
* ಪಿಸಿ ನಾವು ದಶಮಾಂಶ ನೋಡಿ ಹೇಗೆ

372
00:19:47,860 --> 00:19:48,880
ಸ್ಥಳ.

373
00:19:48,880 --> 00:19:54,150
ನಾವು ರೀತಿಯ ಹೇಳಬಹುದು
* ಪಿಸಿ = ಡಿ ಅಥವಾ ಸ್ವಲ್ಪ,

374
00:19:54,150 --> 00:19:59,280
ಮತ್ತು ಏನೇ ಅಂದರೆ
, ಮೆಮೊರಿ ವಿಳಾಸ ಪಿಸಿ ನಲ್ಲಿ

375
00:19:59,280 --> 00:20:07,040
ಯಾವುದೇ ಪಾತ್ರ ಹಿಂದೆ
ನಾವು ಪಿಸಿ = ಡಿ * ಹೇಳಿದರೆ ಅಲ್ಲಿ, ಈಗ ಡಿ.

376
00:20:07,040 --> 00:20:10,090
>> ಇಲ್ಲಿ ನಾವು ಮತ್ತೆ ಹೋಗಿ
ಕೆಲವು ವಿಲಕ್ಷಣ ಸಿ ಸ್ಟಫ್, ಬಲ.

377
00:20:10,090 --> 00:20:14,560
ನಾವು ಎಂದು ಹಿಂದೆ * ನೋಡಿದ
ಹೇಗೋ ಮಾಹಿತಿ ಪ್ರಕಾರ ಭಾಗವಾಗಿ,

378
00:20:14,560 --> 00:20:17,160
ಈಗ ಬಳಸಲಾಗುತ್ತಿದೆ ವಿಶೇಷವೇನು
ಸ್ವಲ್ಪ ಭಿನ್ನ ಸಂದರ್ಭದಲ್ಲಿ

379
00:20:17,160 --> 00:20:19,605
ತಾಣವೊಂದರಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು.

380
00:20:19,605 --> 00:20:22,480
ನಾನು ಇದು ಸ್ವಲ್ಪ ಗೊಂದಲ ಅಂತ ಗೊತ್ತು ಮತ್ತು
ವಾಸ್ತವವಾಗಿ ಈ ಇಡೀ ಭಾಗವಾಗಿದೆ

381
00:20:22,480 --> 00:20:25,740
ಹಾಗೆ ಏಕೆ ಪಾಯಿಂಟರ್ಸ್ ಈ ಪುರಾಣ ಹೊಂದಿವೆ
ಅವುಗಳನ್ನು ಸುಮಾರು ಎಷ್ಟು ಸಂಕೀರ್ಣ ಎಂದು,

382
00:20:25,740 --> 00:20:28,250
ಪ್ರಾಮಾಣಿಕವಾಗಿ, ವಾಕ್ಯ ಸಮಸ್ಯೆ ರೀತಿಯ.

383
00:20:28,250 --> 00:20:31,810
ಆದರೆ * ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಸಲಾಗುವುದು,
ಎರಡೂ ರೀತಿಯ ಹೆಸರಿನ ಭಾಗವಾಗಿ,

384
00:20:31,810 --> 00:20:34,100
ಮತ್ತು ನಾವು ಸ್ವಲ್ಪ ನೋಡುತ್ತಾರೆ
ತುಂಬಾ ನಂತರ ಯಾವುದೋ,.

385
00:20:34,100 --> 00:20:36,490
ಮತ್ತು ಇದೀಗ
dereference ಆಯೋಜಕರು.

386
00:20:36,490 --> 00:20:38,760
ಆದ್ದರಿಂದ ಉಲ್ಲೇಖಿಸುವ ಹೋಗುತ್ತದೆ,
ಇದು ಡೇಟಾ ಪ್ರವೇಶ

387
00:20:38,760 --> 00:20:43,000
ಪಾಯಿಂಟರ್ ಸ್ಥಳ, ಮತ್ತು
ನೀವು ಇಚ್ಛೆಯಂತೆ ಇದು ಕುಶಲತೆಯಿಂದ ಅನುಮತಿಸುತ್ತದೆ.

388
00:20:43,000 --> 00:20:45,900
>> ಈಗ ಈ ಹೋಲುತ್ತದೆ
ನಿಮ್ಮ ನೆರೆಯ ಭೇಟಿ, ಬಲ.

389
00:20:45,900 --> 00:20:48,710
ನೀವು ತಿಳಿದಿದ್ದರೆ ನಿಮ್ಮ
ನೆರೆಯ ನೀವು, ವಾಸಿಸುವ

390
00:20:48,710 --> 00:20:50,730
ನಿಮ್ಮ ನೆರೆಯ ಹ್ಯಾಂಗ್ಔಟ್ ಅಲ್ಲ.

391
00:20:50,730 --> 00:20:53,510
ನೀವು ಸಂಭವಿಸಿ ಗೊತ್ತು
ಅವರು ವಾಸಿಸುವ ಗೊತ್ತು,

392
00:20:53,510 --> 00:20:56,870
ಆದರೆ ಅದಕ್ಕೆ ಎಂದು ಅರ್ಥವಲ್ಲ
ಜ್ಞಾನ ಹೊಂದಿರುವ ಕಾರಣದಿಂದ

393
00:20:56,870 --> 00:20:59,170
ನೀವು ಅವುಗಳನ್ನು ಪರಸ್ಪರ.

394
00:20:59,170 --> 00:21:01,920
ನೀವು ಅವರೊಂದಿಗೆ ಸಂವಹನ ಮಾಡಲು ಬಯಸಿದರೆ,
ನೀವು ಅವರ ಮನೆಗೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ

395
00:21:01,920 --> 00:21:03,760
ನೀವು ಅವರು ವಾಸಿಸುವ ಹೋಗಬೇಕಾಗುತ್ತದೆ.

396
00:21:03,760 --> 00:21:07,440
ಮತ್ತು ನೀವು ಹಾಗೆ ಒಮ್ಮೆ,
ನಂತರ ನೀವು ಸಂವಹನ

397
00:21:07,440 --> 00:21:09,420
ಅವರೊಂದಿಗೆ ನೀವು ಬಯಸುವ ಬಯಸುವ ಇಷ್ಟ.

398
00:21:09,420 --> 00:21:12,730
ಮತ್ತು ಇದೇ ರೀತಿ ವ್ಯತ್ಯಾಸಗಳೊಂದಿಗೆ,
ನೀವು ಅವರ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ಅಗತ್ಯವಿದೆ

399
00:21:12,730 --> 00:21:15,320
ನೀವು ಅವುಗಳನ್ನು ವ್ಯವಹರಿಸಲು ಬಯಸಿದರೆ,
ನೀವು ವಿಳಾಸ ತಿಳಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ.

400
00:21:15,320 --> 00:21:21,495
ಮತ್ತು ನೀವು ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ದಾರಿ
*, dereference ಆಯೋಜಕರು ಬಳಸಲು.

401
00:21:21,495 --> 00:21:23,620
ನೀವು ನಡೆಯುತ್ತದೆ ಯೋಚಿಸುವುದೇನು
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ವೇಳೆ

402
00:21:23,620 --> 00:21:25,260
ಇದರ ಮೌಲ್ಯ ಒಂದು ಪಾಯಿಂಟರ್ ಶೂನ್ಯ?

403
00:21:25,260 --> 00:21:28,470
ಶೂನ್ಯ ಸ್ಮರಿಸುತ್ತಾರೆ
ಪಾಯಿಂಟರ್ ಏನೂ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

404
00:21:28,470 --> 00:21:34,110
ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ಆದ್ದರಿಂದ
ಏನೂ ಒಂದು ವಿಳಾಸವನ್ನು ಏನೂ ಹೋಗಿ ಅಥವಾ,

405
00:21:34,110 --> 00:21:36,800
ನೀವು ಏನಾಗುತ್ತದೆ ತಿಳಿದಿರುವಿರಿ?

406
00:21:36,800 --> 00:21:39,630
ಸರಿ ನೀವು ಊಹಿಸಿದ ವೇಳೆ ವಿಭಜನೆ
ತಪ್ಪು, ನೀವು ಬಲ ಪಡುತ್ತೇವೆ.

407
00:21:39,630 --> 00:21:41,390
ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ವೇಳೆ
ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್,

408
00:21:41,390 --> 00:21:43,140
ನೀವು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ಬಳಲುತ್ತಿದ್ದಾರೆ
ತಪ್ಪು. ಆದರೆ, ನಿರೀಕ್ಷಿಸಿ

409
00:21:43,140 --> 00:21:45,820
ನಾನು, ಹೇಳಲು ಇಲ್ಲ
ನೀವು ಹೋಗುತ್ತಿಲ್ಲ

410
00:21:45,820 --> 00:21:49,220
ನಿಮ್ಮ ಮೌಲ್ಯವನ್ನು ನಿಮ್ಮ
ಅರ್ಥಪೂರ್ಣ ಏನೋ ಸೂಚಿಯಾಗಿದೆ

411
00:21:49,220 --> 00:21:51,000
ನೀವು ಶೂನ್ಯ ಸೆಟ್ ಮಾಡಬೇಕು?

412
00:21:51,000 --> 00:21:55,290
ನಾನು ಮತ್ತು ವಾಸ್ತವವಾಗಿ ವಿಭಜನೆ
ತಪ್ಪು ಉತ್ತಮ ನಡವಳಿಕೆಯ ರೀತಿಯ.

413
00:21:55,290 --> 00:21:58,680
>> ನೀವು ಎಂದಾದರೂ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಘೋಷಿಸಿದರು ಮತ್ತು ಹ್ಯಾವ್
ಕೂಡಲೇ ಮೌಲ್ಯವನ್ನು ಗೊತ್ತುಮಾಡಲಾಗಿದೆ?

414
00:21:58,680 --> 00:22:02,680
ಆದ್ದರಿಂದ ನೀವು ಕೇವಲ ಇಂಟ್ X ಹೇಳುತ್ತಾರೆ; ನೀವು
ನಿಜವಾಗಿ ಏನು ಅದನ್ನು ನಿಯೋಜಿಸಲು

415
00:22:02,680 --> 00:22:05,340
ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಕೋಡ್ ನಲ್ಲಿ,
ನೀವು X ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ

416
00:22:05,340 --> 00:22:07,650
ಇನ್ನೂ ಹೊಂದಿರುವ
ಏನು ಅದನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.

417
00:22:07,650 --> 00:22:10,370
ಪದೇ ಪದೇ ನೀವು ಪಡೆಯುತ್ತೀರಿ
ಶೂನ್ಯ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು

418
00:22:10,370 --> 00:22:15,000
ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಪಡೆಯಲು, ಮತ್ತು ಇರಬಹುದು
ನೀವು ಅದರಿಂದ ಬಂದ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

419
00:22:15,000 --> 00:22:16,750
ಅದೇ ರೀತಿ ವಿಷಯಗಳನ್ನು
ಪಾಯಿಂಟರ್ಸ್ ಸಂಭವಿಸಬಹುದು.

420
00:22:16,750 --> 00:22:20,110
ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ
ಇಂಟ್ * ಉದಾಹರಣೆಗೆ ಎಂಬುದು,

421
00:22:20,110 --> 00:22:23,490
ಮತ್ತು ನೀವು, ಒಂದು ಮೌಲ್ಯಕ್ಕೆ ನಿಯೋಜಿಸಬೇಡಿ
ನೀವು ಮೆಮೊರಿಗೆ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಪಡೆಯಲು.

422
00:22:23,490 --> 00:22:25,950
ಯಾವುದೇ ನಾಲ್ಕು ಬೈಟ್ಗಳು
ವ್ಯವಸ್ಥೆಯ ಮೆಮೊರಿ ಮಾಡಬಹುದು

423
00:22:25,950 --> 00:22:28,970
ಕೆಲವು ಅರ್ಥಪೂರ್ಣ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಹೇಗೆ.

424
00:22:28,970 --> 00:22:31,760
ಮತ್ತು ನಡೆದಿವೆ ಎಂದು
ಈಗಾಗಲೇ ವಿಷಯ

425
00:22:31,760 --> 00:22:34,190
ಮತ್ತೊಂದು ಅಗತ್ಯವಿದೆ ಎಂದಿಗೂ ಇದೆ
ಕಾರ್ಯ, ನೀವು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ

426
00:22:34,190 --> 00:22:35,900
ಯಾವುದೇ ಡೇಟಾವನ್ನು ಇತ್ತು.

427
00:22:35,900 --> 00:22:40,570
>> ನೀವು dereference ಮಾಡಲು ಯತ್ನಿಸಿದರೆ
ನೀವು ಇದ್ದವು don't- ಕೆಲವು ವಿಳಾಸ

428
00:22:40,570 --> 00:22:43,410
ಈಗಾಗಲೇ ಬೈಟ್ಗಳು ಮಾಹಿತಿಯನ್ನು
ಅಲ್ಲಿ, ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಈಗ.

429
00:22:43,410 --> 00:22:47,470
, ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಪಾಯಿಂಟರ್ dereference
ನೀವು ಕೆಲವು ಮೆಮೊರಿ ಗೊಂದಲವನ್ನು ಇರಬಹುದು

430
00:22:47,470 --> 00:22:49,390
ನೀವು ಉದ್ದೇಶ ಎಂದು
ಇದು ಎಲ್ಲಾ ಅವ್ಯವಸ್ಥೆ.

431
00:22:49,390 --> 00:22:51,639
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನೀವು ಮಾಡಬಹುದಾದ
ನಿಜವಾಗಿಯೂ ವಿನಾಶಕಾರಿ ಏನೋ,

432
00:22:51,639 --> 00:22:54,880
ಹಾಗೆ ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಂ ಮುರಿಯಲು,
ಅಥವಾ, ಮತ್ತೊಂದು ಕ್ರಿಯೆ ಮುರಿಯಲು

433
00:22:54,880 --> 00:22:58,289
ಅಥವಾ ದುರುದ್ದೇಶಪೂರಿತ ಏನಾದರೂ
ನಿನ್ನಿಂದ ನನಗೆ ಉದ್ದೇಶ ಇಲ್ಲ.

434
00:22:58,289 --> 00:23:00,080
ಅಷ್ಟೇ ಏಕೆ ಆ ನ
ವಾಸ್ತವವಾಗಿ ಒಳ್ಳೆಯದು

435
00:23:00,080 --> 00:23:04,030
ನೀವು ವೇಳೆ ಶೂನ್ಯ ನಿಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿಸಲು
ಅರ್ಥಪೂರ್ಣ ಏನೋ ಅವುಗಳನ್ನು ಹೊಂದಿಸಲು ಇಲ್ಲ.

436
00:23:04,030 --> 00:23:06,760
ಇದು ಬಹುಶಃ ಉತ್ತಮ
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ದಿನದ ಕೊನೆಯಲ್ಲಿ

437
00:23:06,760 --> 00:23:09,840
ಅದನ್ನು ನಂತರ ಕುಸಿತಕ್ಕೆ
ಏನೋ ಎಂದು ತಿರುಪುಮೊಳೆಗಳು ಅಪ್

438
00:23:09,840 --> 00:23:12,400
ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಮತ್ತೊಂದು ಕ್ರಿಯೆ.

439
00:23:12,400 --> 00:23:15,207
ವರ್ತನೆಯನ್ನು ಸಹ ಕಾರಣವಿರಬಹುದು
ಕೇವಲ ಅಕಸ್ಮಿಕವಾಗಿ ಕಡಿಮೆ ಆದರ್ಶ.

440
00:23:15,207 --> 00:23:17,040
ಅಷ್ಟೇ ಏಕೆ ಆ ನ
ವಾಸ್ತವವಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸ

441
00:23:17,040 --> 00:23:20,920
ನಿಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿಸಲು ಪಡೆಯಲು
ನೀವು ಸೆಟ್ ಇದ್ದರೆ ಶೂನ್ಯ

442
00:23:20,920 --> 00:23:24,540
ಒಂದು ಅರ್ಥಪೂರ್ಣ ಮೌಲ್ಯಕ್ಕೆ
ನಿಮಗೆ ತಕ್ಷಣ, ಈ ಕೆಳಗಿನ

443
00:23:24,540 --> 00:23:27,260
ಮತ್ತು ನೀವು dereference ಸುರಕ್ಷಿತವಾಗಿ ಮಾಡಬಹುದು.

444
00:23:27,260 --> 00:23:32,240
>> ಆದ್ದರಿಂದ ಈಗ ಮರಳಿ ಬರಲಿ ಮತ್ತು ನೋಡೋಣ
ಪರಿಸ್ಥಿತಿಯನ್ನು ಒಟ್ಟಾರೆ ವಾಕ್ಯ.

445
00:23:32,240 --> 00:23:37,400
ನಾನು ಇಂಟ್ * ಪು ಹೇಳಿದರೆ ;, ನಾನು ಏನು ಮಾಡಿದ್ದೇನೆ?

446
00:23:37,400 --> 00:23:38,530
ನಾನು ಮಾಡಿದ ಇದು.

447
00:23:38,530 --> 00:23:43,290
ನಾನು ಪು ಮೌಲ್ಯ ಒಂದು ವಿಳಾಸ ಗೊತ್ತಿಲ್ಲ
ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಕೇವಲ ಏಕೆಂದರೆ

448
00:23:43,290 --> 00:23:44,660
ವಿಳಾಸಗಳನ್ನು.

449
00:23:44,660 --> 00:23:47,750
ನಾನು dereference ಪು
* ಆಯೋಜಕರು ಬಳಸಿ.

450
00:23:47,750 --> 00:23:51,250
ಬಹಳ ಇಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ,
ಟಾಪ್ * ರೀತಿಯ ಭಾಗವಾಗಿದೆ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

451
00:23:51,250 --> 00:23:53,510
ಇಂಟ್ * ಡೇಟಾ ವಿಧ.

452
00:23:53,510 --> 00:23:56,150
ಆದರೆ ನಾನು dereference ಮಾಡಬಹುದು
* ಆಯೋಜಕರು ಬಳಸಿಕೊಂಡು ಪು,

453
00:23:56,150 --> 00:24:01,897
ಮತ್ತು ನಾನು ಹಾಗೆ, ನಾನು ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ವೇಳೆ,
ನಾನು ಆ ವಿಳಾಸದಲ್ಲಿ ಕಾಣಬಹುದು?

454
00:24:01,897 --> 00:24:02,855
ನಾನು ಒಂದು ಪೂರ್ಣಾಂಕ ಕಾಣಬಹುದು.

455
00:24:02,855 --> 00:24:05,910
ಆದ್ದರಿಂದ ಇಂಟ್ * ಪುಟ ಮೂಲತಃ
ಹೇಳುವ ಪು ಒಂದು ವಿಳಾಸ.

456
00:24:05,910 --> 00:24:09,500
ನಾನು ಪು dereference ಮತ್ತು ವೇಳೆ
ನಾನು, ನಾನು ಒಂದು ಪೂರ್ಣಾಂಕ ಕಾಣಬಹುದು

457
00:24:09,500 --> 00:24:11,920
ಮೆಮೊರಿ ಸ್ಥಳದಲ್ಲಿ.

458
00:24:11,920 --> 00:24:14,260
>> ಸರಿ ನಾನು ಮತ್ತೊಂದು ಅವರು ಹೇಳಿದರು
ನಕ್ಷತ್ರಗಳು ಕಿರಿಕಿರಿ ವಿಷಯ

459
00:24:14,260 --> 00:24:17,060
ಮತ್ತು ಇಲ್ಲಿ ಅಲ್ಲೇ
ನಕ್ಷತ್ರಗಳು ಕಿರಿಕಿರಿ ವಿಷಯ.

460
00:24:17,060 --> 00:24:21,640
ನೀವು ಎಂದಾದರೂ ಘೋಷಿಸಲು ಪ್ರಯತ್ನಿಸಿದ್ದಾರೆ
ಅದೇ ರೀತಿಯ ಅನೇಕ ಅಸ್ಥಿರ

461
00:24:21,640 --> 00:24:24,409
ಕೋಡ್ ಅದೇ ಸಾಲಿನಲ್ಲಿ?

462
00:24:24,409 --> 00:24:27,700
ಆದ್ದರಿಂದ ಎರಡನೇ, ಆ ಸಾಲಿನಲ್ಲಿ ನಟಿಸುವುದು
ನಾನು ವಾಸ್ತವವಾಗಿ ಹಸಿರು ಹೊಂದಿರುತ್ತವೆ ಕೋಡ್

463
00:24:27,700 --> 00:24:29,366
ಇಲ್ಲ ಮತ್ತು ಇದು ಕೇವಲ ಇಂಟ್ X, Y, Z ಹೇಳುತ್ತಾರೆ ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
ಏನು ಹಾಗೆ ವಾಸ್ತವವಾಗಿ ರಚಿಸಲು
ನೀವು ಮೂರು ಪೂರ್ಣಾಂಕ ಅಸ್ಥಿರ,

466
00:24:34,550 --> 00:24:36,930
ಒಂದು ಎಂದು X, ಒಂದು ಎಂದು
ವೈ, ಮತ್ತು ಒಂದು z ಎಂದು.

467
00:24:36,930 --> 00:24:41,510
ಇದು ಇಲ್ಲದೆ ಮಾಡಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
ಮೂರು ಸಾಲುಗಳ ಮೇಲೆ ಬೇರ್ಪಡಿಸಲು ಹೊಂದಿರುವ.

468
00:24:41,510 --> 00:24:43,890
>> ನಕ್ಷತ್ರಗಳು ಪಡೆಯಲು ಅಲ್ಲಿ ಇಲ್ಲಿ
ಆದರೂ ಮತ್ತೆ ಕಿರಿಕಿರಿ,

469
00:24:43,890 --> 00:24:49,200
* ವಾಸ್ತವವಾಗಿ ಭಾಗವಾಗಿದೆ ಏಕೆಂದರೆ
ಎರಡೂ ರೀತಿಯ ಹೆಸರು ಮತ್ತು ಭಾಗದ

470
00:24:49,200 --> 00:24:50,320
ವೇರಿಯಬಲ್ ಹೆಸರು.

471
00:24:50,320 --> 00:24:56,430
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಹೇಳಲು ವೇಳೆ ಇಂಟ್ * px ಆಗಿರುತ್ತದೆ, PY, PZ, ನಾನು
ನಿಜವಾಗಿ ಪಡೆಯಲು ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಪಾಯಿಂಟರ್

472
00:24:56,430 --> 00:25:01,650
px ಮತ್ತು ಎರಡು ಪೂರ್ಣಾಂಕಗಳ, PY ಮತ್ತು PZ ಕರೆಯಲಾಗುತ್ತದೆ.

473
00:25:01,650 --> 00:25:04,950
ಮತ್ತು ಬಹುಶಃ ಇಲ್ಲಿದೆ
ನಾವು ಉತ್ತಮ ಅಲ್ಲ, ಬಯಸುವ.

474
00:25:04,950 --> 00:25:09,290
>> ನಾನು ಅನೇಕ ಪಾಯಿಂಟರ್ಸ್ ರಚಿಸಲು ಬಯಸಿದರೆ
ಒಂದೇ ಸಾಲಿನಲ್ಲಿ, ಅದೇ ರೀತಿಯ,

475
00:25:09,290 --> 00:25:12,140
ನಾನು ವಾಸ್ತವವಾಗಿ ಅಗತ್ಯವಿರುವ ಮತ್ತು ನಕ್ಷತ್ರಗಳು,
ಮಾಡಲು * ಪಿಬಿ, * ಪಿಸಿ, ಇಂಟ್ * ಪಾ ಹೇಳಲು ಹೊಂದಿದೆ.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
ಈಗ ಕೇವಲ ಎಂದು ಹೇಳುವ ಮೂಲಕ
ಮತ್ತು ಈಗ, ನೀವು ಈ ಹೇಳುವ

478
00:25:20,300 --> 00:25:22,170
ನೀವು ಬಹುಶಃ ಇದನ್ನು ಎಂದಿಗೂ.

479
00:25:22,170 --> 00:25:25,170
ಮತ್ತು ಇದು, ಪ್ರಾಮಾಣಿಕವಾಗಿ ಬಹುಶಃ ಒಂದು ಒಳ್ಳೆಯ ವಿಷಯ
ನೀವು ತಿಳಿಯದೆ ಇರಬಹುದು ಏಕೆಂದರೆ

480
00:25:25,170 --> 00:25:26,544
ನಕ್ಷತ್ರ, ಆ ರೀತಿಯ ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

481
00:25:26,544 --> 00:25:29,290
ಇದು ಬಹುಶಃ ಘೋಷಿಸಲು ಅತ್ಯುತ್ತಮ ಬಹುಶಃ
ಸಾಲುಗಳನ್ನು 'ಪಾಯಿಂಟರ್ಸ್,

482
00:25:29,290 --> 00:25:31,373
ಆದರೆ ಇದು ಮತ್ತೊಂದು ಒಂದಾಗಿದೆ
ಕಿರಿಕಿರಿ ವಾಕ್ಯ

483
00:25:31,373 --> 00:25:35,310
ಮಾಡುವ ನಕ್ಷತ್ರಗಳು ವಿಷಯಗಳನ್ನು
ಕೆಲಸ ಕಷ್ಟವಾದ ಪಾಯಿಂಟರ್ಸ್.

484
00:25:35,310 --> 00:25:39,480
ಇದು ಕೇವಲ ಈ ವಾಕ್ಯ ಏಕೆಂದರೆ
ಅವ್ಯವಸ್ಥೆ ನೀವು ಮೂಲಕ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

485
00:25:39,480 --> 00:25:41,600
ಅಭ್ಯಾಸ ಅದು
ನಿಜವಾಗಿಯೂ ಎರಡನೇ ಪ್ರಕೃತಿ.

486
00:25:41,600 --> 00:25:45,410
ನಾನು ಇನ್ನೂ ಇನ್ನೂ ಅದನ್ನು ತಪ್ಪುಗಳನ್ನೇ
10 ವರ್ಷಗಳಿಂದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಂತರ,

487
00:25:45,410 --> 00:25:49,630
ಏನೋ ನಡೆಯುತ್ತದೆ ಹಾಗಾಗಿ ಅಸಮಾಧಾನ ಬೇಡಿ
ನಿಮಗೆ, ಪ್ರಾಮಾಣಿಕವಾಗಿ ಬಹಳ ಸಾಮಾನ್ಯವಾಗಿದೆ.

488
00:25:49,630 --> 00:25:52,850
ಇದು ರೀತಿಯ ನಿಜವಾಗಿಯೂ
ವಾಕ್ಯ ನ್ಯೂನತೆಯು.

489
00:25:52,850 --> 00:25:54,900
>> ಸರಿ ನಾನು ರೀತಿಯ ಭರವಸೆ
ನಾವು ಸಂಧಿಸಬೇಕು ಎಂದು

490
00:25:54,900 --> 00:25:59,370
ಎಷ್ಟು ದೊಡ್ಡ ಪರಿಕಲ್ಪನೆಯನ್ನು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.

491
00:25:59,370 --> 00:26:02,750
ಸರಿ ನಾನು ಎಂದು ನೀವು ಹೇಳಿದ
ಸ್ಟ್ರಿಂಗ್, ನಾವು ರೀತಿಯ ನಿಜವಾಗಿಯೂ ಬಂದಿದೆ

492
00:26:02,750 --> 00:26:04,140
ನಿಮಗೆ ಇಡೀ ಸಮಯ ಬಿದ್ದಿದೆ.

493
00:26:04,140 --> 00:26:06,181
ಎಂಬ ಯಾವುದೇ ಮಾಹಿತಿ ಪ್ರಕಾರ ಇಲ್ಲ
ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾನು

494
00:26:06,181 --> 00:26:09,730
ಒಂದು ಈ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ನಮ್ಮ
ಡೇಟಾ ಪ್ರಕಾರಗಳು ಪ್ರಾಚೀನ ವೀಡಿಯೊಗಳು,

495
00:26:09,730 --> 00:26:13,820
ಆ ವಾಕ್ಯವನ್ನು ಒಂದು ಮಾಹಿತಿ ಪ್ರಕಾರ ಎಂದು
cs50.h. ರಲ್ಲಿ ರಚಿಸಲಾಯಿತು

496
00:26:13,820 --> 00:26:17,050
ನೀವು # ಸೇರಿಸಲು ಹೊಂದಿವೆ
ಇದು ಬಳಸಲು cs50.h.

497
00:26:17,050 --> 00:26:19,250
>> ಸರಿ ಸ್ಟ್ರಿಂಗ್ ಕೇವಲ ನಿಜಕ್ಕೂ
ಏನೋ ಅಲಿಯಾಸ್

498
00:26:19,250 --> 00:26:23,600
ಚಾರ್ * ಎಂಬ
ಒಂದು ಪಾತ್ರ ಸೂಚಕವನ್ನು.

499
00:26:23,600 --> 00:26:26,010
ಸರಿ ಪಾಯಿಂಟರ್ಸ್, ಮರುಸ್ಥಾಪನೆ,
ಕೇವಲ ವಿಳಾಸಗಳನ್ನು ಇವೆ.

500
00:26:26,010 --> 00:26:28,780
ಆದ್ದರಿಂದ ಗಾತ್ರ ಏನು
ಒಂದು ತಂತುವಿನ ಬೈಟ್ಗಳು?

501
00:26:28,780 --> 00:26:29,796
ಅಲ್ಲದೆ ಇದು ನಾಲ್ಕರಿಂದ ಎಂಟು ಇಲ್ಲಿದೆ.

502
00:26:29,796 --> 00:26:32,170
ಮತ್ತು ಕಾರಣ ನಾನು ಹೇಳಲು ನಾಲ್ಕು ಅಥವಾ
ಎಂಟು ಏಕೆಂದರೆ ವಾಸ್ತವವಾಗಿ

503
00:26:32,170 --> 00:26:36,730
ನೀವು ಬಳಸುತ್ತಿದ್ದರೆ, ವ್ಯವಸ್ಥೆಯನ್ನು ಅವಲಂಬಿಸಿದೆ
CS50 IDE, ಚಾರ್ * ಚಾರ್ ಗಾತ್ರದಲ್ಲಿರುತ್ತದೆ

504
00:26:36,730 --> 00:26:39,340
* ಇದು 64-ಬಿಟ್ ವ್ಯವಸ್ಥೆ ಇಲ್ಲಿದೆ, ಎಂಟು ಆಗಿದೆ.

505
00:26:39,340 --> 00:26:43,850
ನೆನಪಿಗಾಗಿ ಪ್ರತಿ ವಿಳಾಸ 64 ಬಿಟ್ಗಳು ಉದ್ದವಾಗಿದೆ.

506
00:26:43,850 --> 00:26:48,270
ನೀವು CS50 ಉಪಕರಣಗಳಲ್ಲಿರುವ ಬಳಸುತ್ತಿದ್ದರೆ
ಅಥವಾ ಯಾವುದೇ 32-ಬಿಟ್ ಯಂತ್ರ ಬಳಸಿ,

507
00:26:48,270 --> 00:26:51,640
ಮತ್ತು ನೀವು ಆ ಪದವನ್ನು 32-ಬಿಟ್ ಕೇಳಿರುವ
ಯಂತ್ರ, ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರ ಏನು?

508
00:26:51,640 --> 00:26:56,090
ಹಾಗೆಯೇ ಇದು ಪ್ರತಿ ಅರ್ಥ
ಮೆಮೊರಿ ಸಂಬಂಧಿಸಿದಂತೆ 32 ಬಿಟ್ಗಳು ಉದ್ದವಾಗಿದೆ.

509
00:26:56,090 --> 00:26:59,140
ಆದ್ದರಿಂದ 32 ಬಿಟ್ಗಳು ನಾಲ್ಕು ಬೈಟ್ಗಳು.

510
00:26:59,140 --> 00:27:02,710
ಆದ್ದರಿಂದ ಚಾರ್ * ನಾಲ್ಕರಿಂದ ಎಂಟು ಆಗಿದೆ
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯನ್ನು ಅವಲಂಬಿಸಿ ಬೈಟ್ಗಳು.

511
00:27:02,710 --> 00:27:06,100
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರಗಳು,
ಮತ್ತು ಯಾವುದೇ ಡೇಟಾವನ್ನು ಒಂದು ಪಾಯಿಂಟರ್

512
00:27:06,100 --> 00:27:12,030
ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಕೇವಲ ಏಕೆಂದರೆ, ಟೈಪ್
ವಿಳಾಸಗಳು, ನಾಲ್ಕರಿಂದ ಎಂಟು ಬೈಟ್ಗಳು.

513
00:27:12,030 --> 00:27:14,030
ಆದ್ದರಿಂದ ಅವರ ಈ ಪುನಃ ಅವಕಾಶ
ರೇಖಾಚಿತ್ರ ಮತ್ತು ಅವರ ಅಭಿಪ್ರಾಯ ತಿಳಿಸಿ

514
00:27:14,030 --> 00:27:18,130
ಇಲ್ಲಿ ಸ್ವಲ್ಪ ವ್ಯಾಯಾಮ ಈ ವೀಡಿಯೊ.

515
00:27:18,130 --> 00:27:21,600
ಇಲ್ಲಿ ನಾವು ಜೊತೆಗೆ ಉಳಿದಿದೆ ರೇಖಾಚಿತ್ರ ಇಲ್ಲಿದೆ
ವೀಡಿಯೊ ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ.

516
00:27:21,600 --> 00:27:23,110
ನಾನು * ಬಿಟ್ಟು = 35 ಹೇಳುತ್ತಾರೆ ಆದ್ದರಿಂದ ಇದೀಗ ಏನಾಗುತ್ತದೆ?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
ಆದ್ದರಿಂದ * ಬಿಟ್ಟು = 35, ನಾನು ಹೇಳಲು ಏನು?

519
00:27:30,530 --> 00:27:32,420
ಎರಡನೇ.

520
00:27:32,420 --> 00:27:34,990
* ಎಂಬುದು.

521
00:27:34,990 --> 00:27:39,890
ಇಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ, * ಆಗಿದೆ
dereference ಆಯೋಜಕರು.

522
00:27:39,890 --> 00:27:42,110
ಆದ್ದರಿಂದ dereference
ಆಯೋಜಕರು, ಬಳಸಲಾಗುತ್ತದೆ

523
00:27:42,110 --> 00:27:48,520
ವಿಳಾಸ ತೋರಿಸಿದರು ನಾವು ಹೋಗಿ
ಪಿ.ಕೆ. ಮೂಲಕ ಮತ್ತು ನಾವು ಹೇಗೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಲು.

524
00:27:48,520 --> 00:27:55,270
ಆದ್ದರಿಂದ * ಬಿಟ್ಟು = 35 ಪರಿಣಾಮಕಾರಿಯಾಗಿ
ಚಿತ್ರದ ಮಾಡುತ್ತದೆ.

525
00:27:55,270 --> 00:27:58,110
ಆದ್ದರಿಂದ syntactically ಮೂಲತಃ
ಆಫ್ ಒಂದೇ k = 35 ಹೇಳಿದ್ದಾರೆ.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> ಮತ್ತೊಂದು.

528
00:28:01,930 --> 00:28:05,510
ನಾನು ಇಂಟ್ ಮೀ ಹೇಳಿದರೆ, ನಾನು ರಚಿಸಲು
ಮೀ ಎಂಬ ಹೊಸ ವೇರಿಯಬಲ್.

529
00:28:05,510 --> 00:28:08,260
ಹೊಸ ಬಾಕ್ಸ್, ಇದು ಒಂದು ಹಸಿರು ಬಾಕ್ಸ್ ಏಕೆಂದರೆ ಇಲ್ಲಿದೆ
ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಹಿಡಿಯಲು ಹೋಗುವುದಿಲ್ಲ,

530
00:28:08,260 --> 00:28:09,840
ಮತ್ತು ಇದು ಮೀ ಲೇಬಲ್.

531
00:28:09,840 --> 00:28:14,960
ನಾನು ಮೀ = 4 ಹೇಳಿದರೆ, ನಾನು ಪುಟ್
ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಪೂರ್ಣಾಂಕ.

532
00:28:14,960 --> 00:28:20,290
ಸೇ ಬಿಟ್ಟು = & M, ಹೇಗೆ ಇದ್ದರೆ
ಈ ಚಿತ್ರದಲ್ಲಿ ಬದಲಾವಣೆ?

533
00:28:20,290 --> 00:28:28,760
ಬಿಟ್ಟು = & M, ನೀವು ಏನು ನೆನಪಿಗೆ ಮಾಡಲು
& ಆಯೋಜಕರು ಮಾಡುತ್ತದೆ ಅಥವಾ ಕರೆಯಲಾಗುತ್ತದೆ?

534
00:28:28,760 --> 00:28:34,430
ಎಂದು ಮತ್ತು ಕೆಲವು ವೇರಿಯಬಲ್ ಹೆಸರು ನೆನಪಿಡಿ
ವೇರಿಯಬಲ್ ಹೆಸರು ವಿಳಾಸ.

535
00:28:34,430 --> 00:28:38,740
ಹಾಗಾಗಿ ನಾವು ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ಆಗಿದೆ
ಪಿ.ಕೆ. ಮೀ ವಿಳಾಸ ಪಡೆಯುತ್ತದೆ.

536
00:28:38,740 --> 00:28:42,010
ಆದ್ದರಿಂದ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಏನಾಗುತ್ತದೆ
ರೇಖಾಚಿತ್ರ ಇನ್ನು ಮುಂದೆ ಅಂಕಗಳನ್ನು ಪಿ.ಕೆ. ಆಗಿದೆ

537
00:28:42,010 --> 00:28:46,420
ಮೀ, ಆದರೆ ಅಂಕಗಳನ್ನು ಕೆ ಗೆ.

538
00:28:46,420 --> 00:28:48,470
>> ಮತ್ತೆ ಪಾಯಿಂಟರ್ಸ್ ಬಹಳ ಇವೆ
ಕೆಲಸ ಟ್ರಿಕಿ

539
00:28:48,470 --> 00:28:50,620
ಮತ್ತು ಅವರು ಬಹಳಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಅಭ್ಯಾಸ, ಆದರೆ

540
00:28:50,620 --> 00:28:54,150
ನೀವು ಅವಕಾಶ ತಮ್ಮ ಸಾಮರ್ಥ್ಯದ
ಕಾರ್ಯಗಳನ್ನು ನಡುವೆ ಮಾಹಿತಿ ರವಾನಿಸಲು

541
00:28:54,150 --> 00:28:56,945
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಆ ಹೊಂದಿವೆ
ಬದಲಾವಣೆಗಳು ಪರಿಣಾಮಕಾರಿಯಾಗಲು,

542
00:28:56,945 --> 00:28:58,820
ಸುಮಾರು ನಿಮ್ಮ ತಲೆ ಪಡೆಯುವಲ್ಲಿ
ನಿಜವಾಗಿಯೂ ಮುಖ್ಯ.

543
00:28:58,820 --> 00:29:02,590
ಇದು ಬಹುಶಃ ಅತ್ಯಂತ ಸಂಕೀರ್ಣವಾಗಿದೆ
ನಾವು CS50 ಚರ್ಚಿಸಲು ವಿಷಯ

544
00:29:02,590 --> 00:29:05,910
ಆದರೆ ಮೌಲ್ಯವನ್ನು ನೀವು
ಪಾಯಿಂಟರ್ಗಳನ್ನು ಪಡೆಯುವ

545
00:29:05,910 --> 00:29:09,200
ದೂರದ ತೊಡಕುಗಳು ಮೀರಿಸುತ್ತದೆ
ಅವರಿಗೆ ಕಲಿಕೆ ಬರುತ್ತವೆ.

546
00:29:09,200 --> 00:29:12,690
ಹಾಗಾಗಿ ನೀವು ಅತ್ಯುತ್ತಮ ಬಯಸುವ
ಅದೃಷ್ಟ ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಕಲಿಯಲು.

547
00:29:12,690 --> 00:29:15,760
ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ, ಈ CS50 ಹೊಂದಿದೆ.

548
00:29:15,760 --> 00:29:17,447