1
00:00:00,000 --> 00:00:00,320

2
00:00:00,320 --> 00:00:02,700
>> డేవిడ్ J. మలన్: యొక్క ఒక ప్రోగ్రామ్ను రాయడం లెట్
మేము విలువలు మార్పిడి ప్రయత్నించండి ఇది

3
00:00:02,700 --> 00:00:04,970
రెండు వేరియబుల్స్, x మరియు y.

4
00:00:04,970 --> 00:00:07,490
ముందుగా, నేను వ్రాసినవి చేసిన
ఇప్పటికే ఈ కార్యక్రమం.

5
00:00:07,490 --> 00:00:11,130
మొదటి, నేను ఒక వేరియబుల్, x,
మరియు, అది 1 విలువ నిల్వ.

6
00:00:11,130 --> 00:00:14,120
అప్పుడు నేను వేరియబుల్ y ప్రకటించి
అది విలువ, 2 నిల్వ.

7
00:00:14,120 --> 00:00:17,700
>> అప్పుడు నేను ప్రదర్శించడానికి printf కొనసాగండి
ఆ రెండు అంశాలపై విలువలు.

8
00:00:17,700 --> 00:00:21,090
అప్పుడు నేను మరొక printf దావా
ఆ వేరియబుల్స్ ఇచ్చిపుచ్చుకోవడం వుంటుంది.

9
00:00:21,090 --> 00:00:23,690
అప్పుడు నేను swap అనే ఫంక్షన్ కాల్.

10
00:00:23,690 --> 00:00:26,100
ఆపై ఆ దావా వేరియబుల్స్
మార్చుకున్నారు కలిగి.

11
00:00:26,100 --> 00:00:30,610
ఆపై నేను ప్రింట్ ఏమి నేను దావా
x మరియు y యొక్క కొత్త విలువలు.

12
00:00:30,610 --> 00:00:32,030
>> ఇప్పుడు ఈ ఫంక్షన్ స్వాప్ ఏమిటి?

13
00:00:32,030 --> 00:00:34,970
ఇది C. తో వచ్చే విషయం కాదు
నిజానికి, మేము ఎగువన చూస్తే నా

14
00:00:34,970 --> 00:00:38,850
ఫైలు, మీరు నేను డిక్లేర్డ్ చేసిన గమనించవచ్చు
ఈ ఫంక్షన్ స్వాప్ కోసం ఒక నమూనా

15
00:00:38,850 --> 00:00:42,750
ఇది రెండు ints పడుతుంది తెలుపుతూ,
కక్ష్య ఒక అండ్ బి అని, మరియు ఈ

16
00:00:42,750 --> 00:00:44,300
ఫంక్షన్ ఏదైనా తిరిగి లేదు.

17
00:00:44,300 --> 00:00:48,370
కాబట్టి బహుశా, అది చెప్పే చేస్తుంది
మార్పిడులు ఒక యొక్క మరియు బి యొక్క విలువలలో.

18
00:00:48,370 --> 00:00:50,170
ఇప్పుడు స్వాప్ అమలు లెట్.

19
00:00:50,170 --> 00:00:53,820
>> మొదటి, నేను ఒక తాత్కాలిక డిక్లేర్ వెళుతున్న
వేరియబుల్ మరియు పెట్టేందుకు

20
00:00:53,820 --> 00:00:57,260
ఒక విలువ, అయితే నేను అనుకొనుట
వంటి సులభంగా బి నిల్వ.

21
00:00:57,260 --> 00:01:00,925
నేను విలువ మార్చడానికి వెళుతున్న
ఒక బి ఆ సమానంగా ఉంటుంది.

22
00:01:00,925 --> 00:01:04,849
మరియు తర్వాత చివరగా, నేను మార్చడానికి వెళుతున్న
బి విలువ ఏమి ఒక ఉంది కానీ ఉండాలి

23
00:01:04,849 --> 00:01:06,340
ఇప్పుడు టెంప్ లో.

24
00:01:06,340 --> 00:01:08,910
>> ఇప్పుడు నేను చేసిన దావా
తార్కికంగా సరైనది.

25
00:01:08,910 --> 00:01:12,780
నేను, ఒక తాత్కాలిక వేరియబుల్ ఒక నిల్వ చేసిన
అప్పుడు బి యొక్క ఒక యొక్క విలువ మార్చబడింది, మరియు

26
00:01:12,780 --> 00:01:15,580
ఏమి ఒక యొక్క ఉంది అని బి యొక్క విలువ మార్చబడింది.

27
00:01:15,580 --> 00:01:18,620
కానీ నేను కంపైల్ మరియు ఈ అమలు
కార్యక్రమం, నేను కాదు ఆందోళన

28
00:01:18,620 --> 00:01:20,140
నేను చూసే అన్నారు.

29
00:01:20,140 --> 00:01:21,625
>> , ఏ swap చేయండి.

30
00:01:21,625 --> 00:01:24,350
డాట్, ఏ swap స్లాష్.

31
00:01:24,350 --> 00:01:27,560
మరియు దురదృష్టవశాత్తు, printf ప్రకారం,
x మరియు y యొక్క విలువ, కూడా

32
00:01:27,560 --> 00:01:31,560
మేము ఇచ్చిపుచ్చుకోవడంతో పేర్కొంటున్నాయి తరువాత
వాటిని, ఇప్పటికీ 1 మరియు 2.

33
00:01:31,560 --> 00:01:32,630
>> ఇప్పుడు ఎందుకు అని?

34
00:01:32,630 --> 00:01:36,160
సరే, ఆ అవుతుంది ప్రధాన లో, మేము
లో మీదుగా ఈ ఫంక్షన్ స్వాప్ కాల్

35
00:01:36,160 --> 00:01:39,960
వాదనలు x మరియు y, వాస్తవానికి
x మరియు y యొక్క కాపీలు ఆ

36
00:01:39,960 --> 00:01:41,310
స్వాప్ లోకి వచ్చేస్తాయి.

37
00:01:41,310 --> 00:01:45,430
అవి, వారి విలువలు 1 మరియు 2
ఒక అండ్ బి స్వాప్ వెళ్ళిపోయారు.

38
00:01:45,430 --> 00:01:48,590
మరియు మేము చివరికి అని ఒక అండ్ బి ఉంది
ప్రధాన ఇచ్చిపుచ్చుకోవడం.

39
00:01:48,590 --> 00:01:50,810
>> ఆ 2 1 అవుతుంది, 1 2 అవుతుంది, ఉంది.

40
00:01:50,810 --> 00:01:54,630
కానీ స్వాప్ తిరిగి విలువ కలిగి
మరియు ఎందుకంటే x యొక్క ప్రతులను అందుకున్నారు

41
00:01:54,630 --> 00:01:58,220
మరియు y, ఇది ప్రవర్తన ఉంది
x మరియు y ఎటువంటి ప్రభావం.

42
00:01:58,220 --> 00:02:02,610
నిజానికి, ఒక అండ్ బి మాట్లాడటానికి, దర్శిని గల ఉంటాయి,
x మరియు y ఉన్నాయి అయితే, మారడానికి

43
00:02:02,610 --> 00:02:03,990
ప్రధాన దర్శిని గల.

44
00:02:03,990 --> 00:02:05,070
>> కాబట్టి మేము సమస్య.

45
00:02:05,070 --> 00:02:06,320
కానీ ఎలా వ్రాయాలి?

46
00:02:06,320 --> 00:02:08,312