1
00:00:00,000 --> 00:00:00,520

2
00:00:00,520 --> 00:00:03,530
>> ಸ್ಪೀಕರ್: ತಂದೆಯ ಪ್ರೋಗ್ರಾಂ ಬರೆಯೋಣ ಎಂದು
ಎರಡು ತಂತಿಗಳು ಮತ್ತು ಬಳಕೆದಾರರನ್ನು ಅಪೇಕ್ಷಿಸುತ್ತದೆ

3
00:00:03,530 --> 00:00:07,170
ವರದಿಗಳ ಆ ತಂತಿಗಳು ಎಂಬುದನ್ನು
ಅದೇ ಅದೇ ಅಥವಾ ಅಲ್ಲ.

4
00:00:07,170 --> 00:00:10,290
ನಾನು ಈಗಾಗಲೇ ಇಲ್ಲಿ ನಮಗೆ ಪ್ರಾರಂಭವಾಯಿತು ಬಂದಿದೆ
ಎರಡು ಬಾರಿ printf ಕರೆ ಮತ್ತು ಕರೆ

5
00:00:10,290 --> 00:00:14,520
ರಿಟರ್ನ್ ಸಂಗ್ರಹಿಸುವ, ಎರಡು ಬಾರಿ GetString
ರು ಮತ್ತು ಟಿ ಮೌಲ್ಯಗಳನ್ನು ಕ್ರಮವಾಗಿ.

6
00:00:14,520 --> 00:00:17,960
>> ಈಗ, ನನ್ನ ಸ್ವಭಾವವನ್ನು ಈ ಎರಡು ಹೋಲಿಸಿ
ತಂತಿಗಳನ್ನು ಪರಿಚಿತ ಬಳಸಲು ಎಂದು

7
00:00:17,960 --> 00:00:19,160
ಸಮಾನತೆ ಆಯೋಜಕರು -

8
00:00:19,160 --> 00:00:22,070
ಗಳು ಸಮನಾಗಿರುತ್ತದೆ ಟಿ ಸಮನಾಗಿರುತ್ತದೆ.

9
00:00:22,070 --> 00:00:28,120
ನಂತರ ನಾನು ಮುಂದೆ ಮತ್ತು ಮುದ್ರಣ ಹೋಗಿ ಪಡೆಯಲಿದ್ದೇನೆ
ಔಟ್ "ನೀವು ಅದೇ ವಿಷಯ ಟೈಪ್!

10
00:00:28,120 --> 00:00:35,190
ನಿಜವಾದ ಅಲ್ಲ ವೇಳೆ ಎಲ್ಸ್, ನಾನು ಕೇವಲ ಮನುಷ್ಯ
printf ಟೈಪ್ ಹೋಗುವ ("ನೀವು ಟೈಪಿಸಿದ

11
00:00:35,190 --> 00:00:37,880
ಬೇರೆಬೇರೆ!

12
00:00:37,880 --> 00:00:38,850
>> ಸಾಕಷ್ಟು ನೇರ -

13
00:00:38,850 --> 00:00:41,820
ನಾನು ಕೇವಲ ವಿರುದ್ಧ ಗಳು ಹೋಲಿಸುವ ನಾನು
ಟಿ, ಮತ್ತು ಅವರು ಸಮಾನ ಇಂತಹ,

14
00:00:41,820 --> 00:00:43,250
ಹೆಚ್ಚು ಔಟ್ ಮುದ್ರಣ.

15
00:00:43,250 --> 00:00:45,450
ಈ ಪ್ರೊಗ್ರಾಮ್ ಸಂಕಲಿಸಲು ಮತ್ತು ಔಟ್ ಲೆಟ್.

16
00:00:45,450 --> 00:00:51,950
0 ಹೋಲಿಸಿ ಮಾಡಿ. / ಹೋಲಿಸಿ
0, ಹಲೋ, ಏನೋ ಹೇಳಲು

17
00:00:51,950 --> 00:00:54,200
ಹಲೋ, ಏನೋ ಹೇಳಲು.

18
00:00:54,200 --> 00:00:56,870
>> ದುರದೃಷ್ಟವಶಾತ್, ಪ್ರೋಗ್ರಾಂ ನಾನು ಮಾಡಿದ ಯೋಚಿಸುತ್ತಾನೆ
, ಬೇರೆ ವಸ್ತುಗಳನ್ನು ಟೈಪಿಸಿದ ಸಹ ನಾನು

19
00:00:56,870 --> 00:00:59,530
ಸ್ಪಷ್ಟವಾಗಿ "ಹಲೋ" ಬೆರಳಚ್ಚಿಸಿದ
ಅದೇ ರೀತಿಯಲ್ಲಿ ಎರಡೂ ಬಾರಿ.

20
00:00:59,530 --> 00:01:00,850
ಈಗ, ಏಕೆ ಎಂದು?

21
00:01:00,850 --> 00:01:03,750
>> ಅಲ್ಲದೆ, ಇದು ತಿರುಗಿದರೆ ಈ ಎಲ್ಲಾ
ಸಮಯ, ತಂತಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಬಂದಿವೆ

22
00:01:03,750 --> 00:01:06,780
ಅನುಕ್ರಮದ ಪಾತ್ರಗಳು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ
HOOD ಕೆಳಗೆ.

23
00:01:06,780 --> 00:01:11,450
ವಾಸ್ತವದಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಪಾಯಿಂಟರ್ ಅಥವಾ ಆಗಿದೆ
ವಿಳಾಸ, ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿಳಾಸಕ್ಕೆ

24
00:01:11,450 --> 00:01:14,640
ಎಂದು ಮೊದಲ ಪಾತ್ರದ
ಪಾತ್ರಗಳು ಅನುಕ್ರಮ.

25
00:01:14,640 --> 00:01:18,640
>> ಆದ್ದರಿಂದ ನಾವು ಟಿ ವಿರುದ್ಧ ಗಳು ಹೋಲಿಸಿ
ಸಮಾನ ಸಮ ಚಿಹ್ನೆ, ನಾವು

26
00:01:18,640 --> 00:01:23,200
ವಾಸ್ತವವಾಗಿ ಕೇಳುವ, ಈ ವಿಳಾಸ
ಈ ವಿಳಾಸಕ್ಕೆ ಸಮಾನವಾಗಿದೆ?

27
00:01:23,200 --> 00:01:26,850
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಏರಲಿದೆ ಇದ್ದರೆ
ಬಳಕೆದಾರ ವಿವಿಧ ಎರಡು ಟೈಪಿಸಿದ

28
00:01:26,850 --> 00:01:30,370
ತಂತಿಗಳು ಮತ್ತು ನಾವು ಎರಡು ಬಾರಿ GetString ಕರೆಯಲಾಗುತ್ತದೆ ಬಂದಿದೆ
ಅವುಗಳನ್ನು ಪಡೆಯಲು, ಏಕೆಂದರೆ ಮೆಮೊರಿ

29
00:01:30,370 --> 00:01:34,480
ಎಂದು GetString ಮೊದಲ ಶೇಖರಿಸಿಡಲು ಬಳಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ರಾಮ್ ಇಲ್ಲಿ ಇರಬಹುದು, ಆದರೆ

30
00:01:34,480 --> 00:01:37,120
GetString ಶೇಖರಿಸಿಡಲು ಬಳಸುವ ಮೆಮೊರಿ
ಎರಡನೇ ಸ್ಟ್ರಿಂಗ್ ಹೋಗುತ್ತದೆ

31
00:01:37,120 --> 00:01:38,760
ಇಲ್ಲಿ RAM ಎಂದು.

32
00:01:38,760 --> 00:01:42,380
ಮತ್ತು ಸಹಜವಾಗಿ, ನಂತರ, ಆ ಎರಡು ಭಾಗಗಳಲ್ಲಿ
ಮೆಮೊರಿ ವಿವಿಧ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿವೆ

33
00:01:42,380 --> 00:01:44,220
ತಮ್ಮ ಮೊದಲ ಪಾತ್ರಗಳು.

34
00:01:44,220 --> 00:01:46,120
>> ಆದ್ದರಿಂದ ಸಮಾನ ಎಸ್ ಟಿ ಸಮಾನವಾಗಿರುತ್ತದೆ?

35
00:01:46,120 --> 00:01:46,885
ಅಲ್ಲದೆ, ಯಾವುದೇ.

36
00:01:46,885 --> 00:01:50,510
ರು ಮತ್ತು ಟಿ ವಿವಿಧ ತೋರುತ್ತಿರುವಂತೆ ವೇಳೆ
ಅವರು ಅದಕ್ಕೆ ಎಂದು ಮೆಮೊರಿ ಭಾಗಗಳಲ್ಲಿ,

37
00:01:50,510 --> 00:01:54,140
ಎರಡು ಬಾರಿ, GetString ಕರೆ, ಅವರು, ಇಲ್ಲ
ವಾಸ್ತವವಾಗಿ, ಒಂದೇ ಹೋಗುವ.

38
00:01:54,140 --> 00:01:57,700
ಆದ್ದರಿಂದ ಸಂದರ್ಭದಲ್ಲಿ ತೋರುತ್ತದೆ ಎಂದು
ಅರ್ಥಗರ್ಭಿತ ಎರಡು ಹೋಲಿಸಿ ತಂತಿಗಳನ್ನು

39
00:01:57,700 --> 00:02:01,050
ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ರೀತಿಯಲ್ಲಿ, ಪಾತ್ರದ
ಮೀ, ನಾವು ಮತ್ತೊಂದು ತಂತ್ರ ಅಗತ್ಯವಿದೆ

40
00:02:01,050 --> 00:02:02,300
ಒಟ್ಟಾರೆಯಾಗಿ.

41
00:02:02,300 --> 00:02:03,902