1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
డౌ LLOYD: అన్ని కుడి.

3
00:00:05,580 --> 00:00:08,877
కాబట్టి ఇప్పుడు యొక్క పరిష్కరించడానికి వీలు
నిజంగా పెద్ద టాపిక్, విధులు.

4
00:00:08,877 --> 00:00:11,460
ఇప్పటివరకు కోర్సులో, అన్ని
మేము రాయడం చేసిన కార్యక్రమాలు

5
00:00:11,460 --> 00:00:12,969
ప్రధాన లోపలి వ్రాయడం జరిగింది.

6
00:00:12,969 --> 00:00:14,260
వారు అందంగా సాధారణ కార్యక్రమాలను ఉన్నారు.

7
00:00:14,260 --> 00:00:16,940
మీరు అన్ని ఈ కలిగి అవసరం లేదు
శాఖలు మరియు విషయాలు జరగబోతోంది.

8
00:00:16,940 --> 00:00:18,773
మేము దానిని అన్ని ఇముడుతుంది
ప్రధాన లోపలి మరియు అది

9
00:00:18,773 --> 00:00:20,407
భయంకరమైన అధిక పొందుటకు లేదు.

10
00:00:20,407 --> 00:00:22,990
కానీ కోర్సు గడుస్తూ మరియు
మీరు ప్రోగ్రామ్లను అభివృద్ధి ప్రారంభించగానే

11
00:00:22,990 --> 00:00:26,260
స్వతంత్రంగా, వారు బహుశా చూడాలని
10 కంటే చాలా పొందడానికి ప్రారంభించడానికి

12
00:00:26,260 --> 00:00:27,200
లేదా 15 పంక్తులు.

13
00:00:27,200 --> 00:00:31,400
మీరు వందల లేదా వేల పొందండి ఉండవచ్చు
లేదా పదుల లైన్స్ ఆఫ్ కోడ్ వేల.

14
00:00:31,400 --> 00:00:34,690
అది నిజంగా కాదు
ఒక ఆలోచన ఆ వెర్రి.

15
00:00:34,690 --> 00:00:39,720
అందుకని, బహుశా అది మంచి ఆలోచన కాదు
ప్రధాన లోపలి ప్రతిదీ ఉంచేందుకు.

16
00:00:39,720 --> 00:00:43,240
ఇది కనుగొనేందుకు కొద్దిగా కష్టం పొందవచ్చు
ఏమి మీరు అలా ఉంటే చూస్తున్న.

17
00:00:43,240 --> 00:00:47,040
>> అదృష్టవశాత్తూ, సి, అయితే, మరియు అందంగా చాలా
ప్రతి ఇతర ప్రోగ్రామింగ్ భాష అని

18
00:00:47,040 --> 00:00:50,386
పనిచేయవచ్చు అనుమతిస్తుంది
మాకు విధులు రాయడానికి.

19
00:00:50,386 --> 00:00:52,260
నేను కేవలం వెళుతున్న
పక్కన ఇక్కడ శీఘ్ర పడుతుంది

20
00:00:52,260 --> 00:00:54,971
విధులు అని చెప్పలేదు
కంప్యూటర్ సైన్స్ ఒక ప్రాంతం.

21
00:00:54,971 --> 00:00:57,970
మరియు మీరు వాటిని అనేక మరింత చూస్తారు
కోర్సు అంతటా వివిధ పాయింట్లు

22
00:00:57,970 --> 00:00:59,290
మరియు మీరు కొనసాగించవచ్చు ఉంటే.

23
00:00:59,290 --> 00:01:02,280
ఎక్కడ చాలా ఉంది
అదే పదం కోసం పర్యాయపదాలు.

24
00:01:02,280 --> 00:01:03,390
కాబట్టి మేము విధులు కాల్.

25
00:01:03,390 --> 00:01:05,980
కానీ మీరు కూడా వాటిని వినడానికి ఉండవచ్చు
విధానాలు గా సూచిస్తారు,

26
00:01:05,980 --> 00:01:09,570
లేదా పద్ధతులు, ముఖ్యంగా, మీరు చేసిన ఉంటే ఎప్పుడూ
ఏ ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ పూర్తి

27
00:01:09,570 --> 00:01:11,950
ముందు మరియు ఆందోళన పడకండి
మీరు లేదు, కాదు కలిగి ఉంటే

28
00:01:11,950 --> 00:01:14,280
ఒక పెద్ద deal-- కాని
ఆడిట్ ఆధారిత భాషలు

29
00:01:14,280 --> 00:01:16,129
ఎక్కువగా పిలవబడిన పద్ధతులు ఉన్నాయి.

30
00:01:16,129 --> 00:01:17,670
కొన్నిసార్లు వారు subroutines అని చేస్తున్నారు.

31
00:01:17,670 --> 00:01:20,690
కానీ వారు నిజంగా అన్ని చూడండి
అదే ప్రాథమిక ఆలోచన.

32
00:01:20,690 --> 00:01:22,480
>> ఆ ఆలోచన ఏమిటి చూద్దాం.

33
00:01:22,480 --> 00:01:23,310
ఒక ఫంక్షన్ ఏమిటి?

34
00:01:23,310 --> 00:01:26,470
Well ఒక ఫంక్షన్ నిజంగా
బ్లాక్ బాక్స్ కంటే ఎక్కువ ఏమీ.

35
00:01:26,470 --> 00:01:31,430
సున్నా సమితి కలిగి ఒక బ్లాక్ బాక్స్
మరింత ఇన్పుట్లను మరియు ఒక సింగిల్ అవుట్పుట్ లేదా.

36
00:01:31,430 --> 00:01:33,420
కాబట్టి ఉదాహరణకు, ఈ
ఒక ఫంక్షన్ కావచ్చు.

37
00:01:33,420 --> 00:01:35,510
ఈ func అనే ఫంక్షన్ ఉంది.

38
00:01:35,510 --> 00:01:39,330
మరియు అది మూడు మదుపులు a, b మరియు c పడుతుంది.

39
00:01:39,330 --> 00:01:42,580
మరియు ఆ బ్లాక్ బాక్స్ లోపల, మేము
అది ఖచ్చితంగా ఏమి తెలియదు,

40
00:01:42,580 --> 00:01:45,100
కానీ అది ఇన్పుట్లను ప్రాసెస్
కొన్ని విధంగా ఆపై అది

41
00:01:45,100 --> 00:01:48,680
ఈ సందర్భంలో ఒకే అవుట్పుట్, z ఇస్తుంది.

42
00:01:48,680 --> 00:01:50,504
ఇప్పుడు అది ఒక చిన్న చేయడానికి
తక్కువ వియుక్త మేము

43
00:01:50,504 --> 00:01:52,420
మేము ఆ బహుశా చెప్పగల్గినవి
అనే చర్య

44
00:01:52,420 --> 00:01:58,750
ఆ మూడు మదుపులు a, b పడుతుంది జోడించడానికి, మరియు
సి మరియు కొన్ని విధంగా అవుట్పుట్ ప్రాసెస్

45
00:01:58,750 --> 00:02:01,010
బ్లాక్ బాక్స్ లోపల
ఒకే ఉత్పత్తి.

46
00:02:01,010 --> 00:02:05,190
ఈ సందర్భంలో, చేస్తే
జోడించండి 3, 6, 7 పడుతుంది.

47
00:02:05,190 --> 00:02:07,020
ఎక్కడో లోపల
ఫంక్షన్ జోడించడానికి, మేము చేస్తాను

48
00:02:07,020 --> 00:02:09,750
ఆశించే వాటిని కలిసి జోడించాల్సిన
అవుట్పుట్, ఉత్పత్తి ఇది

49
00:02:09,750 --> 00:02:13,220
3 ప్లస్ 6 ప్లస్ 7 లేదా 16 ఉంది.

50
00:02:13,220 --> 00:02:17,940
>> అదేవిధంగా, మీరు అనే చర్య
రెండు ఇన్పుట్లను, a మరియు b పడుతుంది mult,

51
00:02:17,940 --> 00:02:21,070
కొన్ని విధంగా అటువంటి వాటిని ప్రాసెస్
ఆ ఫంక్షన్ యొక్క అవుట్పుట్

52
00:02:21,070 --> 00:02:22,920
రెండు ఇన్పుట్లను ఉత్పత్తి.

53
00:02:22,920 --> 00:02:25,080
రెండు ఇన్పుట్లను కలిసి గుణించ.

54
00:02:25,080 --> 00:02:29,150
4 మరియు 5, mult జారీ చేయబడిన
ఏదో కాదనీ అవుట్పుట్ జరుగుతుంది

55
00:02:29,150 --> 00:02:31,090
20 ఉంది.

56
00:02:31,090 --> 00:02:32,507
ఎందుకు మేము అది ఒక బ్లాక్ బాక్స్ కాల్ చెయ్యాలి?

57
00:02:32,507 --> 00:02:34,840
మనము రాయడం లేదు ఉంటే
మమ్మల్ని పనిచేస్తుంది

58
00:02:34,840 --> 00:02:36,869
మేము కొంచెం CS50 ఇప్పటివరకు చేసిన.

59
00:02:36,869 --> 00:02:39,910
మేము, ఉదాహరణకు, ముద్రణ F చూసిన ఇది
మేము రాయడానికి లేదు ఒక ఫంక్షన్ ఉంది

60
00:02:39,910 --> 00:02:42,305
మమ్మల్ని, కానీ మేము అన్ని సమయం ఉపయోగించండి లేదు.

61
00:02:42,305 --> 00:02:44,180
మేము రాయడం కాకపోతే
విధులు మేమే

62
00:02:44,180 --> 00:02:48,450
అంతే ఎలా మేము నిజంగా తెలుసుకోవాలి లేదు
నిజానికి, హుడ్ కింద అమలు.

63
00:02:48,450 --> 00:02:51,710
>> ఉదాహరణకు బ్లాక్ బాక్స్ నేను
కేవలం గుణకారానికి మీరు చూపించారు

64
00:02:51,710 --> 00:02:53,740
ఒక mult, బి కావచ్చు
నిర్వచించిన మరియు ఈ కేవలం ఉంది

65
00:02:53,740 --> 00:02:57,902
కొన్ని pseudocode-- కావచ్చు
అవుట్పుట్ సార్లు బి వంటి నిర్వచించవచ్చు.

66
00:02:57,902 --> 00:02:58,860
ఆ సమంజసం, కుడి.

67
00:02:58,860 --> 00:03:01,370
మేము అనే ఫంక్షన్ ఉంటే
రెండు ఇన్పుట్లను పడుతుంది mult.

68
00:03:01,370 --> 00:03:04,750
మేము ఆలోచించే అవుట్పుట్ అని
ఉంటుంది రెండు ఇన్పుట్లను, కలిసి గుణించ

69
00:03:04,750 --> 00:03:06,240
ఒక సార్లు బి.

70
00:03:06,240 --> 00:03:09,170
కానీ mult కూడా కావచ్చు
ఈ వంటి అమలు,

71
00:03:09,170 --> 00:03:13,150
మేము సమర్ధన వేరియబుల్ కలిగి
0 mult లోపల సెట్ చేసుకోగా.

72
00:03:13,150 --> 00:03:18,000
మరియు తర్వాత మేము ఈ విధానాన్ని పునరుక్తి
బి సార్లు కౌంటర్ జోడించండి.

73
00:03:18,000 --> 00:03:24,270
ఉదాహరణకు, మేము ద్వారా 3A గుణిస్తారు ఉంటే
5B, మేము 0 కౌంటర్ సెట్ చెప్పగల్గినవి,

74
00:03:24,270 --> 00:03:27,700
అయిదు సార్లు పునరావృతం కౌంటర్ 3 జోడించండి.

75
00:03:27,700 --> 00:03:34,490
కాబట్టి మేము 0 వద్ద మొదలు మరియు అప్పుడు మేము
ఈ ఐదు సార్లు 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
ఇది అదే ఫలితం. మేము
ఇప్పటికీ పొందుటకు 3 సార్లు 5 కేవలం

77
00:03:37,500 --> 00:03:39,500
అమలు భిన్నంగా ఉంటుంది.

78
00:03:39,500 --> 00:03:41,490
>> మేము ఉద్దేశ్యం ఏమిటి
మేము ఒక బ్లాక్ బాక్స్ చెప్పినప్పుడు.

79
00:03:41,490 --> 00:03:44,406
ఇది కేవలం మేము నిజంగా పట్టించుకోను అర్థం
ఇది హుడ్ కింద అమలు ఎలా

80
00:03:44,406 --> 00:03:46,170
కాలం అవుట్పుట్ కాదనీ ఏమిటి.

81
00:03:46,170 --> 00:03:49,045
నిజానికి, ఆ ఒప్పందం భాగంగా
ముఖ్యంగా, విధులు ఉపయోగించి

82
00:03:49,045 --> 00:03:50,630
ఇతరులు వ్రాసే పనులను.

83
00:03:50,630 --> 00:03:53,980
ప్రవర్తన ఎప్పుడూ అన్నారు
అనూహ్యమైన విలక్షణ అని

84
00:03:53,980 --> 00:03:55,420
చర్య యొక్క పేరును ఆధారంగా.

85
00:03:55,420 --> 00:03:57,500
ఇది నిజంగా ఎందుకు మరియు ఆ
ముఖ్యమైన మీరు విధులు రాయడానికి

86
00:03:57,500 --> 00:04:00,020
లేదా తర్వాత ఇతర వ్యక్తులు రాయడానికి
మీరు ఉపయోగించుకునే విధులు,

87
00:04:00,020 --> 00:04:03,590
ఆ విధులు కలిగి
స్పష్టమైన, సాపేక్షంగా స్పష్టమైన పేర్లు,

88
00:04:03,590 --> 00:04:04,990
బాగా డాక్యుమెంట్ చెయ్యబడ్డాయి.

89
00:04:04,990 --> 00:04:08,560
ఇది ఖచ్చితంగా సందర్భంలో
ముద్రణ F వంటి ఫంక్షన్ కోసం.

90
00:04:08,560 --> 00:04:09,860
>> సో ఎందుకు మేము విధులు ఉపయోగించగలను?

91
00:04:09,860 --> 00:04:14,220
సరే నేను మేము వ్రాయడానికి ఉంటే, ముందు ఇలా
ప్రధాన విషయాలు లోపల మా కోడ్ అన్ని

92
00:04:14,220 --> 00:04:17,120
నిజంగా గజిబిజిగా పొందవచ్చు
మరియు నిజంగా సంక్లిష్టంగా.

93
00:04:17,120 --> 00:04:19,980
విధులు మాకు సామర్ధ్యానికి అనుమతిస్తాయి
విషయాలు నిర్వహించడానికి మరియు విచ్ఛిన్నం

94
00:04:19,980 --> 00:04:24,540
చాలా క్లిష్టమైన సమస్య
చాలా ఎక్కువగా నిర్వహించటానికి ఉప భాగాలు.

95
00:04:24,540 --> 00:04:28,130
విధులు కూడా మమ్మల్ని అనుమతించడం
కోడింగ్ విధానాన్ని సులభం.

96
00:04:28,130 --> 00:04:33,080
ఇది 10 డీబగ్ చాలా సులభం
100 లైన్ వర్సెస్ లైన్ ఫంక్షన్

97
00:04:33,080 --> 00:04:35,890
ఫంక్షన్ లేదా ఒక 1,000 లైన్ ఫంక్షన్.

98
00:04:35,890 --> 00:04:38,400
మేము మాత్రమే డీబగ్ కలిగి ఉంటే
ఒక సమయంలో చిన్న ముక్కలు,

99
00:04:38,400 --> 00:04:42,110
లేదా, సమయంలో చిన్న ముక్కలు రాయడానికి
ఆ ప్రోగ్రామింగ్ అనుభవం చేస్తుంది

100
00:04:42,110 --> 00:04:43,070
చాలా మంచి.

101
00:04:43,070 --> 00:04:44,910
ఒక నన్ను నమ్మండి.

102
00:04:44,910 --> 00:04:48,400
>> చివరగా, మేము విధులు వ్రాస్తే మేము
ఆ వివిధ ప్రాంతాల్లో మళ్లీ మళ్లీ.

103
00:04:48,400 --> 00:04:49,880
విధులు రీసైకిల్ చేయవచ్చు.

104
00:04:49,880 --> 00:04:51,880
వారు ఉపయోగించవచ్చు
ఒక ప్రోగ్రామ్ లేదా మరొక.

105
00:04:51,880 --> 00:04:53,713
మీరు ఇప్పటికే వ్రాయలేదు
ఫంక్షన్, అన్ని మీరు

106
00:04:53,713 --> 00:04:56,530
ఆ కార్యక్రమం చెప్పడం చెయ్యాల్సిన
పేరు ఆ ఫంక్షన్ కనుగొనేందుకు.

107
00:04:56,530 --> 00:04:59,680
మేము రీసైక్లింగ్ మరియు ఉపయోగించి పరిష్కరించగలుగుతున్నాము
కోసం 40 సంవత్సరాల f ప్రింట్.

108
00:04:59,680 --> 00:05:02,150
కానీ అది ఒకే సమయం రాయబడింది.

109
00:05:02,150 --> 00:05:04,270
ప్రెట్టీ ఉపయోగకరమైన, కుడి.

110
00:05:04,270 --> 00:05:04,830
అయితే సరే.

111
00:05:04,830 --> 00:05:06,040
సో విధులు గొప్ప ఉన్నాయి.

112
00:05:06,040 --> 00:05:06,860
మేము తెలుసు.

113
00:05:06,860 --> 00:05:08,700
ఇప్పుడు వాటిని రాయడం ప్రారంభిద్దాం.

114
00:05:08,700 --> 00:05:10,830
యొక్క పొందడానికి ప్రారంభించడానికి లెట్
వాటిని మా కార్యక్రమాలుగా.

115
00:05:10,830 --> 00:05:13,869
మొదటి క్రమంలో అలా
మేము మీకు విషయం ఫంక్షన్ డిక్లేర్ ఉంది.

116
00:05:13,869 --> 00:05:16,160
మీరు ఒక ఫంక్షన్ డిక్లేర్ చేసినప్పుడు
ఏమి మీరు ప్రధానంగా చేస్తున్నా

117
00:05:16,160 --> 00:05:18,900
కంపైలర్ చెప్తుంటాడు,
హే, మీరు తెలిసిన,

118
00:05:18,900 --> 00:05:20,850
నేను వ్రాసే వెళుతున్న చేస్తున్నాను
తర్వాత ఒక ఫంక్షన్

119
00:05:20,850 --> 00:05:22,987
మరియు ఇక్కడ అది లాగా జరగబోతోంది ఏమిటి.

120
00:05:22,987 --> 00:05:24,820
ఈ కారణం
కంపైలర్లు ఎందుకంటే

121
00:05:24,820 --> 00:05:27,900
ఉంటే కొన్ని విచిత్రమైన పనులు
వారు చిహ్నాలు సమితి చూడండి

122
00:05:27,900 --> 00:05:29,560
వారు మీకు తెలియకపోతే ఆ.

123
00:05:29,560 --> 00:05:33,000
కాబట్టి మేము కేవలం కంపైలర్ ఒక ఇవ్వాలని
హెచ్చరిక, నేను ఒక ఫంక్షన్ సృష్టించడం నేను

124
00:05:33,000 --> 00:05:35,492
మరియు దీన్ని జరగబోతోంది.

125
00:05:35,492 --> 00:05:38,450
ఫంక్షన్ ప్రకటనలు సాధారణంగా ఉంటే
మీరు ఒక మార్గం మీ కోడ్ ఆర్గనైజింగ్ చేస్తున్నారు

126
00:05:38,450 --> 00:05:41,872
ఇతరులకు చెయ్యగలరు
అర్థం మరియు ఉపయోగించుకుంటాయి,

127
00:05:41,872 --> 00:05:44,330
మీరు సాధారణంగా అన్ని ఉంచాలి కావలసిన
మీ ఫంక్షన్ ప్రకటనలు

128
00:05:44,330 --> 00:05:48,220
మీ కోడ్ అగ్రభాగాన, కుడి
మీరు కూడా ప్రధాన రాయటం మొదలుపెట్టాలని ముందు.

129
00:05:48,220 --> 00:05:50,770
మరియు సౌకర్యవంతంగా ఉంది
చాలా ప్రామాణిక రూపం

130
00:05:50,770 --> 00:05:53,500
ప్రతి ఫంక్షన్ ప్రకటన అనుసరిస్తుంది.

131
00:05:53,500 --> 00:05:56,090
వారు అన్ని చాలా చక్కని ఇలా.

132
00:05:56,090 --> 00:06:01,440
మూడు భాగాలు ఒక ఫంక్షన్ ఉన్నాయి
ప్రకటన తిరిగి రకం, పేరు,

133
00:06:01,440 --> 00:06:03,420
మరియు వాదన జాబితా.

134
00:06:03,420 --> 00:06:07,180
>> ఇప్పుడు తిరిగి టైప్ ఏ విధమైన
వేరియబుల్ ఫంక్షన్ సంకల్పం అవుట్పుట్.

135
00:06:07,180 --> 00:06:10,710
కాబట్టి ఉదాహరణకు, ఒకవేళ మేము తిరిగి అనుకుంటున్నాను
రెండు గుణించడం క్రితం నిమిషం

136
00:06:10,710 --> 00:06:15,690
సంఖ్యలు ఫంక్షన్, మేము చేస్తే ఆశించే లేదు
మేము ఒక పూర్ణాంకం ద్వారా పూర్ణాంకం గుణిస్తారు

137
00:06:15,690 --> 00:06:18,502
అవుట్పుట్ ఉంటుంది
బహుశా పూర్ణాంకం, కుడి.

138
00:06:18,502 --> 00:06:20,710
గుణిస్తే రెండు పూర్ణాంకాల
కలిసి, మీరు పూర్ణాంకం పొందండి.

139
00:06:20,710 --> 00:06:24,167
ఆ తిరిగి రకం కాబట్టి
ఫంక్షన్ పూర్ణాంకానికి ఉంటుంది.

140
00:06:24,167 --> 00:06:26,000
పేరు మీరు ఏమి ఉంది
మీ ఫంక్షన్ కాల్.

141
00:06:26,000 --> 00:06:29,330
ఈ బహుశా కనీసం ముఖ్యం
ఫంక్షన్ ప్రకటన భాగంగా,

142
00:06:29,330 --> 00:06:30,827
కార్యాచరణ పరంగా.

143
00:06:30,827 --> 00:06:33,160
కానీ వాస్తవానికి బహుశా ఒకటి
ముఖ్య భాగాలు

144
00:06:33,160 --> 00:06:36,243
పరంగా ఫంక్షన్ ప్రకటన యొక్క
తెలుసుకోవడం ఫంక్షన్ వాస్తవానికి ఏమి

145
00:06:36,243 --> 00:06:37,120
లేదు.

146
00:06:37,120 --> 00:06:40,474
మీ ఫంక్షన్ f ఆర్ g పేరు ఉంటే లేదా
h లేదా రహస్య లేదా అలాంటిదే,

147
00:06:40,474 --> 00:06:42,765
మీరు బహుశా పొందడానికి వెళుతున్న
కొద్దిగా ప్రయత్నిస్తున్న జారారు

148
00:06:42,765 --> 00:06:44,650
ఆ విధులు ఏమి గుర్తుంచుకోవడానికి.

149
00:06:44,650 --> 00:06:47,880
కనుక ఇది ఇవ్వాలని ముఖ్యం మీ
ఫంక్షన్ యొక్క అర్ధవంతమైన పేర్లు.

150
00:06:47,880 --> 00:06:51,030
>> చివరగా, వాదన జాబితా
కామాతో వేరుచేయబడిన

151
00:06:51,030 --> 00:06:55,260
మీ ఫంక్షన్ అన్ని ఇన్పుట్లను,
వీటిలో ఒక్కోటి రకం మరియు ఒక పేరు ఉంది.

152
00:06:55,260 --> 00:06:57,840
సో మీరు మాత్రమే ఉన్నాయి
వేరియబుల్ ఏ రకాన్ని పేర్కొనాలి

153
00:06:57,840 --> 00:07:00,760
ఫంక్షన్ సంకల్పం అవుట్పుట్,
మీరు కూడా తెలుపుటకు కావలసిన

154
00:07:00,760 --> 00:07:07,694
ఏ రకం మరియు వేరియబుల్స్ రకాలు
ఫంక్షన్ ఇన్పుట్లను వంటి అంగీకరించడం చేయబడుతుంది.

155
00:07:07,694 --> 00:07:08,860
కాబట్టి యొక్క ఇక్కడ ఒక ఉదాహరణ తెలియజేసేలా.

156
00:07:08,860 --> 00:07:10,220
యొక్క కేవలం పరిశీలించి లెట్
మరింత కాంక్రీటు ఒకటి వద్ద.

157
00:07:10,220 --> 00:07:13,130
కాబట్టి ఇక్కడ ఒక చర్య యొక్క ఒక ఉదాహరణ వార్తలు
ఒక ఫంక్షన్ కోసం ప్రకటన

158
00:07:13,130 --> 00:07:14,925
కలిసి రెండు పూర్ణాంకాల చేర్చుతారు.

159
00:07:14,925 --> 00:07:17,800
రెండు పూర్ణాంకాల మొత్తం అన్నారు
పూర్ణాంకం, అలాగే మేము కేవలం

160
00:07:17,800 --> 00:07:18,450
చర్చించారు.

161
00:07:18,450 --> 00:07:21,610
కాబట్టి తిరిగి టైప్
ఇక్కడ గ్రీన్, Int ఉంటుంది.

162
00:07:21,610 --> 00:07:25,190
కేవలం రెండు ints జోడించండి అని మాకు చెబుతుంది
రోజు చివరిలో, అన్నారు,

163
00:07:25,190 --> 00:07:28,799
అవుట్పుట్, లేదా తిరిగి ఉమ్మి
మాకు ఎత్తి పూర్ణాంకాలు.

164
00:07:28,799 --> 00:07:31,590
ఈ ఫంక్షన్ మేము ఏమి ఇచ్చిన
అది ఒక అర్ధవంతమైన పేరు ఇవ్వాలని.

165
00:07:31,590 --> 00:07:33,630
రెండు ints తెలుస్తోంది జోడించండి
తగిన పరిగణనలోకి

166
00:07:33,630 --> 00:07:37,574
మేము ఇన్పుట్లను వంటి రెండు పూర్ణాంకాల వేస్తున్నాము
మరియు ఆశాజనక వాటిని కలిసి జోడించడం.

167
00:07:37,574 --> 00:07:40,240
ఇది ఒక గజిబిజిగా ఒక బిట్ కావచ్చు
పేరు మరియు స్పష్టముగా ఈ ఫంక్షన్

168
00:07:40,240 --> 00:07:42,430
బహుశా అవసరం లేదు
మేము అదనంగా నుండీ

169
00:07:42,430 --> 00:07:46,310
ఆపరేటర్లు, మీరు నుండి గుర్తుకు ఉంటే మా
గతంలో ఆపరేటర్ల చర్చ.

170
00:07:46,310 --> 00:07:49,650
కానీ యొక్క కేవలం కొరకు అని పిలవబడు
ఈ ఫంక్షన్ ఉపయోగపడుతుంది ఆ వాదన

171
00:07:49,650 --> 00:07:52,860
అందువలన మేము అది రెండు ints జోడించండి పిలుస్తాను.

172
00:07:52,860 --> 00:07:55,230
చివరగా, ఈ ఫంక్షన్ రెండు ఇన్పుట్లను పడుతుంది.

173
00:07:55,230 --> 00:07:56,960
వీటిలో ప్రతి ఒక పూర్ణ సంఖ్య.

174
00:07:56,960 --> 00:07:59,900
కాబట్టి మేము ఈ కామాతో కలిగి
ప్రవేశాంశాల వేరు జాబితా.

175
00:07:59,900 --> 00:08:02,830
ఇప్పుడు మేము సాధారణంగా కావలసిన
వాటిని ప్రతి ఒక పేరు ఇచ్చి

176
00:08:02,830 --> 00:08:05,070
వారు ఉపయోగించవచ్చు కాబట్టి
ఫంక్షన్ లోపల.

177
00:08:05,070 --> 00:08:07,180
పేర్లు భయంకరమైన ముఖ్యమైనది కాదు.

178
00:08:07,180 --> 00:08:11,400
>> ఈ సందర్భంలో, మేము తప్పనిసరిగా లేదు
వాటిని జత ఏ అర్థం.

179
00:08:11,400 --> 00:08:13,140
కాబట్టి మేము కేవలం వాటిని ఒక అండ్ బి కాల్ చేయవచ్చు.

180
00:08:13,140 --> 00:08:14,257
ఆ పూర్తిగా మంచిది.

181
00:08:14,257 --> 00:08:16,090
అయితే, మీరు కనుగొనడానికి
ఒక పరిస్థితిలో మీరే

182
00:08:16,090 --> 00:08:19,497
పేరు వేరియబుల్స్ యొక్క పేర్లు
నిజానికి ముఖ్యమైన కావచ్చు,

183
00:08:19,497 --> 00:08:21,830
మీరు వాటిని కాల్ అనుకోవచ్చు
a మరియు b కంటే ఇతర ఏదైనా

184
00:08:21,830 --> 00:08:24,701
వాటిని మరింత ఏదో ఇవ్వాలని
ప్రతీకాత్మకంగా అర్ధవంతమైన.

185
00:08:24,701 --> 00:08:27,700
కానీ ఈ సందర్భంలో, మేము నిజంగా
ఫంక్షన్ గురించి ఏదైనా తెలుసు.

186
00:08:27,700 --> 00:08:29,320
మేము కేవలం రెండు పూర్ణాంకాల జోడించాలనుకుంటే.

187
00:08:29,320 --> 00:08:32,429
కాబట్టి మేము కేవలం పిలుస్తాను
ఆ పూర్ణాంకాల ఒక అండ్ బి.

188
00:08:32,429 --> 00:08:33,990
ఒక ఉదాహరణ ఉంది.

189
00:08:33,990 --> 00:08:36,287
>> మీరు రెండవ పడుతుంది లేదు ఎందుకు
ఈ గురించి ఆలోచించడం,

190
00:08:36,287 --> 00:08:38,870
ఎలా మీరు ఒక ఫంక్షన్ రాస్తుంది
ఒక ఫంక్షన్ కోసం ప్రకటన

191
00:08:38,870 --> 00:08:42,940
రెండు ఫ్లోటింగ్ పాయింట్ సంఖ్యల్లో గుణిస్తారు?

192
00:08:42,940 --> 00:08:45,910
మీరు ఏమి ఒక గుర్తు లేదా
ఫ్లోటింగ్ పాయింట్ సంఖ్య?

193
00:08:45,910 --> 00:08:48,120
ఈ పనిచేస్తుంటాయి చేస్తాను
ప్రకటన కనిపిస్తుంది?

194
00:08:48,120 --> 00:08:53,330
నేను నిజానికి మీరు వీడియోకు విరామము సిఫార్సు
ఇక్కడ మరియు మీరు అవసరం ఎంత సమయం పడుతుంది.

195
00:08:53,330 --> 00:08:55,521
ఏమి ఈ గురించి ఆలోచించండి
ఫంక్షన్ ప్రకటన ఉంటుంది?

196
00:08:55,521 --> 00:08:56,770
తిరిగి టైప్ అంటే ఏమిటో?

197
00:08:56,770 --> 00:08:58,103
ఒక అర్ధవంతమైన పేరు ఏమిటి?

198
00:08:58,103 --> 00:08:59,580
ఇన్పుట్లను ఏమిటి?

199
00:08:59,580 --> 00:09:03,190
ఎందుకు మీరు ఇక్కడ వీడియోకు విరామము లేదు
మరియు వ్రాయడం అప్ ఒక ఫంక్షన్ ప్రకటన

200
00:09:03,190 --> 00:09:07,640
గుణిస్తారు అని ఒక ఫంక్షన్ కోసం
కలిసి రెండు ఫ్లోటింగ్ పాయింట్ సంఖ్యలు.

201
00:09:07,640 --> 00:09:09,330
ఆశాజనక మీరు వీడియో పాజ్.

202
00:09:09,330 --> 00:09:12,950
>> కాబట్టి యొక్క ఒక ఉదాహరణ పరిశీలించి లెట్
ఒక సాధ్యం ప్రకటన పట్ల వ్యక్తంచేసారు.

203
00:09:12,950 --> 00:09:17,340
Mult రెండు reals, ఫ్లోట్ y, x తేలుతూ తీసుకువస్తారు.

204
00:09:17,340 --> 00:09:19,090
రెండు ఉత్పత్తి
ఫ్లోటింగ్ పాయింట్ సంఖ్యల్లో,

205
00:09:19,090 --> 00:09:21,710
ఇది గుర్తుకు ఎలా ఉంటాయి మేము
వాస్తవ సంఖ్యలు ప్రాతినిధ్యం

206
00:09:21,710 --> 00:09:26,770
లేదా సి దశాంశ విలువలతో సంఖ్యలు,
ఒక ఫ్లోటింగ్ పాయింట్ సంఖ్యలు అవతరిస్తుంది.

207
00:09:26,770 --> 00:09:28,570
మీరు ఒక గుణిస్తారు చేసినప్పుడు
ఒక దశాంశ ద్వారా దశాంశ,

208
00:09:28,570 --> 00:09:30,460
మీరు బహుశా ఒక దశాంశ పొందడానికి వెళుతున్న.

209
00:09:30,460 --> 00:09:31,960
మీరు ఒక సంబంధిత పేరు ఇవ్వాలని.

210
00:09:31,960 --> 00:09:33,810
రెండు reals గుణకారం జరిమానా తెలుస్తోంది.

211
00:09:33,810 --> 00:09:36,620
కానీ మీరు నిజంగా కాల్ కాలేదు
mult రెండు తేలటం, లేదా mult తేలియాడే.

212
00:09:36,620 --> 00:09:39,540
అది ఉన్నంత ఆ వంటి ఏదైనా,
కొన్ని వాస్తవ అర్థాన్ని ఇచ్చింది ఏమి

213
00:09:39,540 --> 00:09:41,469
ఈ బ్లాక్ బాక్స్ చేయబోవడం జరిగినది.

214
00:09:41,469 --> 00:09:44,260
మరియు తిరిగి, ఈ సందర్భంలో, మేము లేదు
ఏ అర్థం వాడడానికి కనిపిస్తుంది

215
00:09:44,260 --> 00:09:46,390
పేర్ల వరకు
మేము అక్కడ చేస్తున్నారు వేరియబుల్స్

216
00:09:46,390 --> 00:09:48,645
కాబట్టి మేము కేవలం వాటిని x మరియు y కాల్.

217
00:09:48,645 --> 00:09:51,020
మీరు ఏదో వాటిని కాల్ ఇప్పుడు ఉంటే
వేరే, ఆ పూర్తిగా మంచిది.

218
00:09:51,020 --> 00:09:53,310
నిజానికి, మీరు చేస్తే
ఈ ప్రకటన బదులుగా

219
00:09:53,310 --> 00:09:55,450
బదులుగా డబుల్స్ ఉపయోగించి
మీరు గుర్తు ఉంటే యొక్క, తేలుతుంది

220
00:09:55,450 --> 00:09:59,100
డబుల్స్ వేరే అని
మార్గం మరింత ఖచ్చితంగా

221
00:09:59,100 --> 00:10:02,330
వాస్తవ సంఖ్యలు పేర్కొనండి లేదా
పాయింట్ వేరియబుల్స్ తేలు.

222
00:10:02,330 --> 00:10:03,620
ఆ చాలా పూర్తిగా మంచిది.

223
00:10:03,620 --> 00:10:04,670
గాని ఆ ఒకటి జరిమానా ఉంటుంది.

224
00:10:04,670 --> 00:10:06,711
నిజానికి, అనేక ఉన్నాయి
వివిధ కలయికలు

225
00:10:06,711 --> 00:10:08,410
మార్గాలు ఈ ఫంక్షన్ ప్రకటించాలని.

226
00:10:08,410 --> 00:10:10,884
కానీ ఈ రెండు అందమైన మంచి కావలి.

227
00:10:10,884 --> 00:10:12,550
మేము ఆ గొప్ప, ఒక ఫంక్షన్ డిక్లేర్డ్ చేసిన.

228
00:10:12,550 --> 00:10:15,700
మేము దానిని కంపైలర్ చెప్పారు చేసిన
, మనం చేస్తున్న చూడాలని ఉంది.

229
00:10:15,700 --> 00:10:17,630
ఇప్పుడు నిజంగా ఆ ఫంక్షన్ వ్రాయండి.

230
00:10:17,630 --> 00:10:20,750
ఇది ఒక నిర్వచనం ఇవ్వాలని లెట్,
తద్వారా బ్లాక్ బాక్స్ లోపల

231
00:10:20,750 --> 00:10:22,840
ఊహాజనిత ప్రవర్తన జరిగింది.

232
00:10:22,840 --> 00:10:26,270
నిజానికి, మేము రెండు వాస్తవ గుణించడం ఉంటాయి
కలిసి సంఖ్యలు లేదా జోడించడం సంఖ్యలు

233
00:10:26,270 --> 00:10:29,760
కలిసి, లేదా సంసార చేయడం
ఆ మేము మా ఫంక్షన్ కోరారు.

234
00:10:29,760 --> 00:10:32,780
>> కాబట్టి నిజానికి, యొక్క ప్రయత్నించండి మరియు నిర్వచించే తెలియజేయండి
రెండు reals గుణిస్తారు ఇది మేము కేవలం

235
00:10:32,780 --> 00:10:35,350
రెండవ క్రితం గురించి మాట్లాడారు.

236
00:10:35,350 --> 00:10:38,560
ఇప్పుడు ప్రారంభంలో
ఒక ఫంక్షన్ నిర్వచనం

237
00:10:38,560 --> 00:10:41,720
దాదాపు అదే కనిపిస్తుంది
ఒక ఫంక్షన్ ప్రకటన.

238
00:10:41,720 --> 00:10:43,170
నేను ఇక్కడ వాటిని రెండు కలిగి.

239
00:10:43,170 --> 00:10:47,770
ఎగువన ఫంక్షన్ ప్రకటన ఉంది,
రకం, పేరు, కామాతో వేరుచేయబడిన వాదన

240
00:10:47,770 --> 00:10:49,410
జాబితా సెమికోలన్.

241
00:10:49,410 --> 00:10:53,800
సెమికోలన్ సూచిస్తుంది
ఒక ఫంక్షన్ ప్రకటన.

242
00:10:53,800 --> 00:10:57,060
విధి ప్రారంభంలో
నిర్వచనం దాదాపు ఖచ్చితంగా ఉంది

243
00:10:57,060 --> 00:11:03,790
అదే రకం, పేరు, కామాతో వేరుచేయబడిన
వాదన జాబితా, ఏ సెమికోలన్,

244
00:11:03,790 --> 00:11:05,206
వంకర కలుపు తెరవండి.

245
00:11:05,206 --> 00:11:07,580
బహిరంగ వంకర జంట కలుపు, అంతే
మేము ప్రధాన తో చేయడం పరిష్కరించగలుగుతున్నాము

246
00:11:07,580 --> 00:11:09,540
మేము ఇప్పుడు అర్థం
నిర్వచించే మొదలయ్యాయి

247
00:11:09,540 --> 00:11:14,567
ఏమి బ్లాక్ బాక్స్ లోపల జరుగుతుంది
మేము mult రెండు reals కాల్ నిర్ణయించుకుంది చేసిన.

248
00:11:14,567 --> 00:11:15,900
ఇక్కడ అది అమలు ఒక మార్గం.

249
00:11:15,900 --> 00:11:20,370
మేము ఒక కొత్త డిక్లేర్ కాలేదు చెప్పగల్గినవి
రకం ఫ్లోట్ అని ఉత్పత్తి యొక్క వేరియబుల్

250
00:11:20,370 --> 00:11:24,020
ఆ వేరియబుల్ కేటాయించి
విలువ x సార్లు y కు.

251
00:11:24,020 --> 00:11:27,306
ఆపై ఉత్పత్తి తిరిగి.

252
00:11:27,306 --> 00:11:28,430
తిరిగి ఇక్కడ అర్థం ఏమిటి.

253
00:11:28,430 --> 00:11:31,090
అలాగే తిరిగి మార్గం
ఎలా మేము సూచిస్తూ

254
00:11:31,090 --> 00:11:33,400
మేము అవుట్పుట్ వెనక్కి ప్రయాణిస్తున్న చేస్తున్నారు.

255
00:11:33,400 --> 00:11:38,160
కాబట్టి అదే, ఏదో తిరిగి,
ఈ బ్లాక్ బాక్స్ యొక్క అవుట్పుట్ ఉంది.

256
00:11:38,160 --> 00:11:40,732
మీరు దీన్ని ఎలా కాబట్టి ఆ.

257
00:11:40,732 --> 00:11:42,190
ఇక్కడ అది అమలు మరొక మార్గం.

258
00:11:42,190 --> 00:11:45,050
మేము కేవలం y, x సార్లు తిరిగి చేరుకునేవారు.

259
00:11:45,050 --> 00:11:45,870
x ఒక ఫ్లోట్ ఉంది.

260
00:11:45,870 --> 00:11:46,660
y ఫ్లోట్ ఉంది.

261
00:11:46,660 --> 00:11:48,490
సార్లు x సో y కూడా ఒక ఫ్లోట్ ఉంది.

262
00:11:48,490 --> 00:11:50,750
మేము కూడా అవసరం లేదు
మరొక వేరియబుల్ సృష్టించండి.

263
00:11:50,750 --> 00:11:56,750
కాబట్టి ఆ వేరే మార్గం వార్తలు
ఖచ్చితమైన అదే బ్లాక్ బాక్స్ అమలు.

264
00:11:56,750 --> 00:11:58,570
>> ఇప్పుడు ఒక్క క్షణం ఆగి,
మళ్ళీ వీడియో విరామం

265
00:11:58,570 --> 00:12:01,680
మరియు, రెండు ints జోడించండి ప్రయత్నించండి మరియు నిర్వచించే
ఇతర ఫంక్షన్ అని మేము

266
00:12:01,680 --> 00:12:03,090
ఒక క్షణం క్రితం గురించి మాట్లాడారు.

267
00:12:03,090 --> 00:12:06,440
మళ్ళీ ఇక్కడ, నేను ఫంక్షన్ ఉంచాము
ప్రకటన, అందువలన సెమికోలన్,

268
00:12:06,440 --> 00:12:08,420
మరియు ఒక ఓపెన్ వంకర కలుపు
మరియు ఒక సంవృత గిరజాల

269
00:12:08,420 --> 00:12:12,080
మేము పూరించడానికి పేరు కలుపు సూచించడానికి
విషయాలు, రెండు ints జోడించండి

270
00:12:12,080 --> 00:12:15,530
మేము ముఖ్యంగా నిర్వచించే కాబట్టి
బ్లాక్ బాక్స్ లోపల ప్రవర్తన.

271
00:12:15,530 --> 00:12:16,380
కాబట్టి వీడియోకు విరామము.

272
00:12:16,380 --> 00:12:18,790
మరియు ఎక్కువ సమయం పడుతుంది
మీరు ప్రయత్నించండి మరియు నిర్ణయించుకోవాలి

273
00:12:18,790 --> 00:12:25,040
ఒక అమలును రెండు ints జోడించండి, ఇటువంటి
ఆ ఫంక్షన్ క్రింది అందిస్తుంది ఉన్నప్పుడు,

274
00:12:25,040 --> 00:12:29,209
నిజానికి, చేస్తుంది, తిరిగి
రెండు ఇన్పుట్లను మొత్తం.

275
00:12:29,209 --> 00:12:32,000
కాబట్టి కేవలం మునుపటి ఉదాహరణకు వంటి,
అనేక వివిధ మార్గాలు ఉన్నాయి

276
00:12:32,000 --> 00:12:34,210
మీరు అమలు చేయగల రెండు ints జోడించండి.

277
00:12:34,210 --> 00:12:35,130
ఇక్కడ ఒకటి.

278
00:12:35,130 --> 00:12:37,172
ఇక్కడ నారింజ లో నేను చేసిన
కొన్ని comments-- కలిగి

279
00:12:37,172 --> 00:12:38,880
నేను కొన్ని జోడించిన
వ్యాఖ్యలు సూచించడానికి

280
00:12:38,880 --> 00:12:41,400
ఏమి కోడ్ యొక్క ప్రతి లైన్ జరుగుతున్నది.

281
00:12:41,400 --> 00:12:45,430
నేను ఒక వేరియబుల్ డిక్లేర్
రకం Int మొత్తం అని.

282
00:12:45,430 --> 00:12:47,279
నేను మొత్తం కూడిక b సమానం చెప్పడానికి.

283
00:12:47,279 --> 00:12:50,070
మేము నిజంగా చేస్తున్న పేర్కొంది
పని జోడించడం మరియు కలిసి b.

284
00:12:50,070 --> 00:12:51,850
మరియు నేను మొత్తం తిరిగి.

285
00:12:51,850 --> 00:12:56,460
మరియు ఆ కోణంలో ఎందుకంటే చేస్తుంది
మొత్తం రకం Int ఒక చరరాశి.

286
00:12:56,460 --> 00:13:00,180
మరియు డేటాను ఈ టైప్ ఏమిటి
ఫంక్షన్ అవుట్పుట్ జరగబోతోంది నాకు చెబుతుంది?

287
00:13:00,180 --> 00:13:00,680
Int.

288
00:13:00,680 --> 00:13:03,072
కాబట్టి నేను మొత్తం తిరిగి నేను ఇది
పూర్ణాంకం వేరియబుల్ ఉంది.

289
00:13:03,072 --> 00:13:06,030
మరియు ఆ కోణంలో మేము చేసిన ఏమి ఇచ్చిన చేస్తుంది
డిక్లేర్డ్ మరియు మా ఫంక్షన్ నిర్వచించిన

290
00:13:06,030 --> 00:13:07,320
చెయ్యవలసిన.

291
00:13:07,320 --> 00:13:09,700
>> ఇప్పుడు మీరు కూడా నిర్వచించలేదు
ఫంక్షన్ ఈ విధంగా,

292
00:13:09,700 --> 00:13:15,260
Int మొత్తం ఆ skip b-- ఒక ప్లస్ సమానం
step-- అప్పుడు మొదటి మరియు మొత్తం తిరిగి.

293
00:13:15,260 --> 00:13:17,760
ఇప్పుడు మీరు కూడా కలిగి కాలేదు
అది ఈ విధంగా అమలు

294
00:13:17,760 --> 00:13:19,180
ఇది నేను అత్యంత సిఫార్సు లేదు.

295
00:13:19,180 --> 00:13:22,540
ఈ ఒక చెడు శైలి
విషయం మరియు నిజంగా చెడు డిజైన్,

296
00:13:22,540 --> 00:13:24,420
కానీ అది వాస్తవం, పనిలో, చేస్తుంది.

297
00:13:24,420 --> 00:13:30,199
మీరు Int ఇది ఈ కోడ్, తీసుకోకపోతే
చెడు కట్లపాము డాట్ జోడించండి సి, మరియు అది ఉపయోగించడానికి.

298
00:13:30,199 --> 00:13:31,990
ఇది నిజానికి జత చేస్తుంది
కలిసి రెండు పూర్ణాంకాల.

299
00:13:31,990 --> 00:13:37,632
ఇది ఒక చాలా పేద అమలు వార్తలు
ఈ ప్రత్యేక ప్రవర్తన.

300
00:13:37,632 --> 00:13:38,340
కానీ అది పని లేదు.

301
00:13:38,340 --> 00:13:41,200
ఇది వర్ణించేందుకు కేవలం ఇక్కడ వార్తలు
మేము నిజంగా ఆ పాయింట్

302
00:13:41,200 --> 00:13:44,530
లోపల ఏమి పట్టించుకోను
కాలం బ్లాక్ బాక్స్

303
00:13:44,530 --> 00:13:46,510
అది కాదనీ ఆ అవుట్పుట్ ఉంది అని.

304
00:13:46,510 --> 00:13:48,870
ఈ పేలవంగా రూపొందించిన బ్లాక్ బాక్స్.

305
00:13:48,870 --> 00:13:53,801
కానీ చివరిలో రోజు, అది
ఇప్పటికీ అవుట్పుట్ ఒక ప్లస్ బి మొత్తం.

306
00:13:53,801 --> 00:13:54,300
అయితే సరే.

307
00:13:54,300 --> 00:13:56,320
కాబట్టి మేము విధులు డిక్లేర్డ్ చేసిన.

308
00:13:56,320 --> 00:13:57,490
మరియు మేము ఫంక్షన్ నిర్వచించిన చేసిన.

309
00:13:57,490 --> 00:13:58,540
తద్వారా నిజంగా బావుంటుంది.

310
00:13:58,540 --> 00:14:03,020
ఇప్పుడు విధులు ఉపయోగించడానికి ప్రారంభిద్దాం
మేము డిక్లేర్డ్ చేసిన మరియు మేము నిర్వచించిన చేసిన.

311
00:14:03,020 --> 00:14:05,960
వాస్తవానికి ఒక ఫంక్షన్ కాల్
మీరు చెయ్యాల్సిన అన్ని అందంగా easy--

312
00:14:05,960 --> 00:14:09,070
తగిన వాదనలు దానిని పాస్ ఉంది,
డేటా రకం వాదనలు

313
00:14:09,070 --> 00:14:11,600
అది ఆశించటం, మరియు
అప్పుడు తిరిగి కేటాయించి

314
00:14:11,600 --> 00:14:15,190
ఆ ఫంక్షన్ యొక్క విలువ
మరియు దీన్ని అవసరం లేదు నాకు

315
00:14:15,190 --> 00:14:19,390
ఆ ఫంక్షన్ తిరిగి లెక్కించాల్సి
సరైన పద్ధతి యొక్క ఏదో.

316
00:14:19,390 --> 00:14:22,410
>> కాబట్టి యొక్క వద్ద ఒక లుక్ కలిగి తెలపండి
ఒక ఫైల్ లో ఈ ఆచరణ

317
00:14:22,410 --> 00:14:27,730
అని కట్లపాము 1 డాట్ సి, ఇది
నేను నా CS50 IDE లో కలిగి.

318
00:14:27,730 --> 00:14:31,042
కాబట్టి ఇక్కడ కట్లపాము 1 డాట్ సి ఉంది.

319
00:14:31,042 --> 00:14:33,500
ప్రారంభంలో మీరు నేను చూడండి
నా కలిగి, పౌండ్, ఉన్నాయి

320
00:14:33,500 --> 00:14:35,460
ప్రామాణిక IO, మరియు CS50 డాట్ h.

321
00:14:35,460 --> 00:14:37,700
అప్పుడు నేను నా ఫంక్షన్ ప్రకటన చేశారు.

322
00:14:37,700 --> 00:14:39,570
నేను ఇక్కడ ఈ ఉంది
నేను కంపైలర్ చెప్పడం

323
00:14:39,570 --> 00:14:42,850
ఒక వ్రాయడం వెళుతున్న
అనే రెండు ints జోడించండి.

324
00:14:42,850 --> 00:14:45,780
ఇది ఫలితం ఒక జరగబోతోంది
పూర్ణాంకం రకం వేరియబుల్.

325
00:14:45,780 --> 00:14:47,360
ఈ భాగం ఇక్కడే ఏమిటి.

326
00:14:47,360 --> 00:14:51,950
ఆపై నేను ఒక రెండు ఇన్పుట్లను కలిగి
మరియు b ఇది ప్రతి పూర్ణాంకం ఉంది.

327
00:14:51,950 --> 00:14:58,250
ప్రధాన లోపలి, నేను వినియోగదారుని అభ్యర్థించడం
చెప్పి ఇన్పుట్ నాకు ఒక పూర్ణాంకం ఇస్తాయి.

328
00:14:58,250 --> 00:15:01,040
మరియు వారు మర్చిపోతే ప్రాంప్ట్
ఒక ఫంక్షన్ ఇది Int,

329
00:15:01,040 --> 00:15:03,240
CS50 లైబ్రరీ చేర్చారు.

330
00:15:03,240 --> 00:15:07,660
మరియు ఆ లో నిల్వ కావాలి
x, పూర్ణాంకం వేరియబుల్.

331
00:15:07,660 --> 00:15:09,886
>> అప్పుడు మేము మరొక పూర్ణాంకం కోసం ప్రాంప్ట్.

332
00:15:09,886 --> 00:15:13,070
మేము మరొక పూర్ణ సంఖ్య
మరియు y అని నిల్వ.

333
00:15:13,070 --> 00:15:17,990
ఆపై, ఇక్కడ లైన్ 28 న,
ఇక్కడ మేము మా ఫంక్షన్ కాల్ చేయడానికి.

334
00:15:17,990 --> 00:15:23,770
మేము, Int z సమానం అంటున్నారు
2 ints x కామా y జోడించండి.

335
00:15:23,770 --> 00:15:25,980
ఈ అర్ధమే ఎందుకు మీరు చూస్తారు?

336
00:15:25,980 --> 00:15:29,710
x పూర్ణాంకం రకం మారుతూ ఉంటుంది మరియు
y పూర్ణాంకం రకం చరరాశి.

337
00:15:29,710 --> 00:15:31,220
కాబట్టి ఆ బావుంటుంది.

338
00:15:31,220 --> 00:15:34,570
ఏమి మా ఫంక్షన్ తో ఆ సమంజసం
లైన్ 17 న డిక్లరేషన్ వలె కనిపిస్తుంది.

339
00:15:34,570 --> 00:15:38,300
కామాతో వేరుచేయబడిన ఇన్పుట్ జాబితా
రెండు పూర్ణాంకాల, a మరియు b ఆశించారు.

340
00:15:38,300 --> 00:15:40,300
ఆ సందర్భంలో, మేము కాల్ చేయవచ్చు
వాటిని సంసార మేము కావలసిన.

341
00:15:40,300 --> 00:15:42,300
ఇది కేవలం రెండు పూర్ణాంకాల ఆశించారు.

342
00:15:42,300 --> 00:15:44,930
మరియు x ఒక పూర్ణ సంఖ్య మరియు y పూర్ణాంకం ఉంది.

343
00:15:44,930 --> 00:15:45,640
ఆ పనిచేస్తుంది.

344
00:15:45,640 --> 00:15:48,680
>> మరియు మేము ఆ ఫంక్షన్ అవతరిస్తుంది తెలుసు
అవుట్పుట్ ఒక పూర్ణాంకాల అలాగే.

345
00:15:48,680 --> 00:15:51,290
కాబట్టి మేము నిల్వ ఉంటాయి
పనితీరు అవుట్పుట్,

346
00:15:51,290 --> 00:15:56,050
పూర్ణాంకం రకం, రెండు ints జోడించండి
వేరియబుల్, మేము z కాల్ చేస్తున్నారు, ఇది.

347
00:15:56,050 --> 00:16:01,980
మరియు తర్వాత మేము, మొత్తం చెప్పగలను
శాతం నేను మరియు శాతం నేను శాతం ఉంది.

348
00:16:01,980 --> 00:16:06,210
x, y మరియు z వరుసగా
ఆ శాతం నేను యొక్క పూరించి.

349
00:16:06,210 --> 00:16:08,334
యొక్క నిర్వచనం ఏమిటి
రెండు ints వంటి చూడండి జోడించడానికి?

350
00:16:08,334 --> 00:16:09,125
ఇది చాలా సులభం.

351
00:16:09,125 --> 00:16:11,270
ఇది వాటిని ఒకటి మేము
కేవలం రెండవ క్రితం చూసిన

352
00:16:11,270 --> 00:16:14,390
Int మొత్తం కూడిక b తిరిగి మొత్తం సమానం.

353
00:16:14,390 --> 00:16:15,420
ఈ పని చేస్తుంది?

354
00:16:15,420 --> 00:16:17,270
ఫైలు సేవ్ చేసేలా.

355
00:16:17,270 --> 00:16:22,080
ఆపై డౌన్ ఇక్కడ నా టెర్మినల్
నేను కట్లపాము 1 తయారు వెళుతున్న

356
00:16:22,080 --> 00:16:23,000
మరియు నేను నా స్క్రీన్ క్లియర్.

357
00:16:23,000 --> 00:16:25,791
నేను తెలుసు ఎందుకంటే దూరంగా వెళుతున్న
అది చూడటానికి ఒక చిన్న కష్టం.

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> కాబట్టి మేము కట్లపాము 1 గా ఈ కార్యక్రమం కంపైల్.

360
00:16:33,770 --> 00:16:37,910
కాబట్టి మేము డాట్ స్లాష్ కట్లపాము 1 చేయవచ్చు.

361
00:16:37,910 --> 00:16:40,060
10 నాకు ఒక పూర్ణాంకం ఇవ్వండి.

362
00:16:40,060 --> 00:16:42,380
20 నాకు మరొక పూర్ణాంకం ఇవ్వండి.

363
00:16:42,380 --> 00:16:45,200
10 మరియు 20 మొత్తం 30 అవుతుంది.

364
00:16:45,200 --> 00:16:47,615
కాబట్టి మేము ఒక విజయవంతమైన ఫంక్షన్ కాల్ చేసింది.

365
00:16:47,615 --> 00:16:55,820
మీరు ప్రతికూల మళ్ళీ ఫంక్షన్ అమలు చెయ్యవచ్చు
10, ప్రతికూల 10 మరియు 17 యొక్క 17 మొత్తం 7.

366
00:16:55,820 --> 00:16:57,120
ఈ ఫంక్షన్ పనిచేస్తుంది.

367
00:16:57,120 --> 00:16:59,240
ఇది ప్రవర్తన కలిగి
మేము అది ఆశించే.

368
00:16:59,240 --> 00:17:03,610
కాబట్టి మేము ఒక విజయవంతమైన చేసిన
ఫంక్షన్, నిర్వచనం డిక్లరేషన్,

369
00:17:03,610 --> 00:17:07,288
మరియు ఒక విజయవంతమైన ఫంక్షన్ కాల్.

370
00:17:07,288 --> 00:17:09,079
జంట ఇతరాలు
విధులు గురించి పాయింట్లు

371
00:17:09,079 --> 00:17:10,611
మేము ఈ విభాగంలో ముగించారు ముందు.

372
00:17:10,611 --> 00:17:12,319
నుండి గుర్తు మా
డేటా రకాల చర్చ,

373
00:17:12,319 --> 00:17:16,109
గతంలో విధులు
కొన్నిసార్లు ఏ ఇన్పుట్లను పడుతుంది.

374
00:17:16,109 --> 00:17:17,930
ఒకవేళ, మేము
ఫంక్షన్ ప్రకటించాలని

375
00:17:17,930 --> 00:17:19,788
ఒక గర్జన వాదన జాబితా కలిగి ఉన్నట్లు.

376
00:17:19,788 --> 00:17:21,579
మీరు ఏమి గుర్తు లేదు
అత్యంత సాధారణ ఫంక్షన్

377
00:17:21,579 --> 00:17:25,036
మేము ఇప్పటివరకు పడుతుంది చూసిన
ఒక గర్జన వాదన జాబితా ఉంది?

378
00:17:25,036 --> 00:17:27,300
ఇది ప్రధాన వార్తలు.

379
00:17:27,300 --> 00:17:30,850
కొన్నిసార్లు ఆ ఫంక్షన్ గుర్తుచేసుకున్నారు
నిజానికి ఒక అవుట్పుట్ లేదు.

380
00:17:30,850 --> 00:17:34,210
ఆ సందర్భంలో, మేము ఫంక్షన్ ప్రకటించాలని
ఒక గర్జన తిరిగి టైప్ కలిగి ఉన్నట్లు.

381
00:17:34,210 --> 00:17:37,880
యొక్క ఈ విభాగం నిర్ధారించారు లెట్
ఒక సాధన సమస్య పరిష్కారంలో.

382
00:17:37,880 --> 00:17:39,900
>> కాబట్టి ఇక్కడ వేశాడు సమస్య.

383
00:17:39,900 --> 00:17:43,630
నేను మీరు ఒక ఫంక్షన్ రాయాలనుకుంటున్నాను
చెల్లుబాటు అయ్యే త్రిభుజం అంటారు.

384
00:17:43,630 --> 00:17:47,410
ఈ ఫంక్షన్ ఏమి చెయ్యాలి
మూడు వాస్తవ సంఖ్యలు పడుతుంది

385
00:17:47,410 --> 00:17:51,930
ఆ మూడు పొడవులను సూచిస్తాయి
దాని పారామితులు ఒక త్రిభుజం భుజాల,

386
00:17:51,930 --> 00:17:54,550
లేదా దాని వాదనలు, లేదా దాని
పర్యాయపదాలు మరొక సెట్ ఇన్పుట్లను

387
00:17:54,550 --> 00:17:57,340
మీరు ఎదుర్కొనే కొన్ని.

388
00:17:57,340 --> 00:18:01,120
ఈ ఫంక్షన్ తప్పక
అవుట్పుట్ గాని నిజమైన లేదా తప్పుడు

389
00:18:01,120 --> 00:18:04,960
ఆధారపడి ఆ మూడు పొడవులు లేదో
ఒక త్రిభుజం తయారు చేసే సామర్థ్యాన్ని కలిగి ఉంటాయి.

390
00:18:04,960 --> 00:18:09,930
మీరు డేటా రకం గుర్తుపెట్టుకొవాలి
మేము నిజమైన లేదా తప్పుడు సూచించడానికి ఉపయోగిస్తారు?

391
00:18:09,930 --> 00:18:11,436
ఇప్పుడు మీరు ఈ ఎలా అమలు చెయ్యాలి?

392
00:18:11,436 --> 00:18:13,810
Well ఒక జంట ఉన్నాయి తెలుసు
త్రిభుజాలు సంబంధించిన నియమాలు

393
00:18:13,810 --> 00:18:15,480
వాస్తవానికి తెలిసిన ఉపయోగకరంగా ఉంటాయి.

394
00:18:15,480 --> 00:18:18,292
ఒక త్రిభుజం మాత్రమే కలిగి
సానుకూల పొడవు వైపులా.

395
00:18:18,292 --> 00:18:19,000
ఆ అర్ధమే.

396
00:18:19,000 --> 00:18:21,432
మీరు బహుశా ప్చ్, చెబుతున్న.

397
00:18:21,432 --> 00:18:23,390
ఇతర విషయం గమనించండి
అయితే, మొత్తం ఉంది

398
00:18:23,390 --> 00:18:25,484
ఏ పొడవుల
త్రిభుజం యొక్క రెండు వైపులా

399
00:18:25,484 --> 00:18:27,650
కంటే ఎక్కువ ఉండాలి
మూడవ భుజం యొక్క పొడవు.

400
00:18:27,650 --> 00:18:28,690
వాస్తవానికి నిజం.

401
00:18:28,690 --> 00:18:34,150
మీరు వైపులా 1 త్రిభుజం ఉండకూడదు
ఉదాహరణకు 2 మరియు 4, 1 ప్లస్ 2 ఎందుకంటే

402
00:18:34,150 --> 00:18:36,270
4 కంటే ఎక్కువ కాదు.

403
00:18:36,270 --> 00:18:38,870
ఆ కాబట్టి నియమాలు అని
గుర్తించడానికి మూడు లేదో

404
00:18:38,870 --> 00:18:42,740
ఇన్పుట్లను మందుల ఒక త్రిభుజం ఏర్పాటు చేయవచ్చు.

405
00:18:42,740 --> 00:18:46,360
కాబట్టి నిమిషాల ఒక జంట పడుతుంది
మరియు ప్రకటించి అప్పుడు నిర్వచించలేదు

406
00:18:46,360 --> 00:18:49,810
చెల్లుబాటు అయ్యే అని ఈ ఫంక్షన్
త్రిభుజం అటువంటి వాస్తవానికి

407
00:18:49,810 --> 00:18:51,650
ఇక్కడ పేర్కొన్న ప్రవర్తన కలిగి ఉంది.

408
00:18:51,650 --> 00:18:57,030
>> ఇది అవుట్పుట్ నిజమైన ఆ మూడు వైపులా ఉంటే
ఒక త్రిభుజం శ్రమజీవులు సామర్థ్యాన్ని కలిగి ఉంటాయి

409
00:18:57,030 --> 00:19:01,950
మరియు తప్పుడు లేకపోతే
మీరు చేసిన ఎలా చూడటానికి రెడీ?

410
00:19:01,950 --> 00:19:04,650
ఇక్కడ ఒకటి అమలు వార్తలు
లోపములను త్రిభుజం.

411
00:19:04,650 --> 00:19:05,770
ఇది మాత్రమే ఒకటి కాదు.

412
00:19:05,770 --> 00:19:07,770
యువర్స్ కొద్దిగా మారవచ్చును.

413
00:19:07,770 --> 00:19:11,040
కానీ ఈ ఒక నిజానికి, కలిగి, చేస్తుంది
మేము ఆశించిన ఆ ప్రవర్తన.

414
00:19:11,040 --> 00:19:14,450
మేము వద్ద మా ఫంక్షన్ ప్రకటించాలని
అగ్రభాగాన, చెల్లుబాటు అయ్యే త్రిభుజం bool

415
00:19:14,450 --> 00:19:16,630
x ఫ్లోట్ y ఫ్లోట్ z తీసుకువస్తారు.

416
00:19:16,630 --> 00:19:18,930
మరలా, ఈ ఫంక్షన్
మూడు వాస్తవ సంఖ్యలు పడుతుంది

417
00:19:18,930 --> 00:19:22,280
దాని వాదనలు, ఫ్లోటింగ్
పాయింట్ విలువ వేరియబుల్స్

418
00:19:22,280 --> 00:19:26,510
మరియు నిజమైన లేదా తప్పుడు అందిస్తుంది
బూలియన్, రీకాల్ ఇది విలువ.

419
00:19:26,510 --> 00:19:28,660
తిరిగి టైప్ bool ఎందుకు కాబట్టి ఆ.

420
00:19:28,660 --> 00:19:30,016
అప్పుడు మేము ఫంక్షన్ వివరిస్తాయి.

421
00:19:30,016 --> 00:19:33,140
మేము మొదటి విషయం నిర్ధారించుకోండి ఉంది
ఆ భుజాల అన్ని సానుకూల ఉన్నాయి.

422
00:19:33,140 --> 00:19:37,010
X కంటే తక్కువ లేదా సమానంగా ఉంటే
0, y లేదా 0 సమానంగా ఉంటే,

423
00:19:37,010 --> 00:19:41,050
లేదా z కంటే తక్కువ లేదా 0 సమానంగా ఉంటే
ఆ బహుశా ఒక త్రిభుజం ఉండకూడదు.

424
00:19:41,050 --> 00:19:42,380
వారు అనుకూల వైపులా లేదు.

425
00:19:42,380 --> 00:19:45,790
కాబట్టి మేము తిరిగి చేయవచ్చు
ఆ పరిస్థితిలో తప్పుడు.

426
00:19:45,790 --> 00:19:49,010
తరువాత, మేము నిర్ధారించుకోండి
ఇన్పుట్లను ప్రతి జత

427
00:19:49,010 --> 00:19:51,830
మూడవ ఒకటి కంటే ఎక్కువ ఉంటుంది.

428
00:19:51,830 --> 00:19:54,530
>> కాబట్టి x ప్లస్ y తక్కువ ఉంటే
z కంటే లేదా సమానం,

429
00:19:54,530 --> 00:19:57,060
లేదా x ప్లస్ z తక్కువ ఉంటే
y కంటే లేదా సమానం,

430
00:19:57,060 --> 00:20:01,730
లేదా y ప్లస్ z ఉంటే కంటే తక్కువ లేదా సమానం
x, కూడా ఒక చెల్లుబాటు అయ్యే త్రిభుజం ఉండకూడదు.

431
00:20:01,730 --> 00:20:03,800
కనుక మనం మళ్ళీ తప్పుడు తిరిగి.

432
00:20:03,800 --> 00:20:06,900
ఊహిస్తే మేము తనిఖీలు రెండు ఆమోదించింది
అయితే, అప్పుడు మేము నిజమైన తిరిగి.

433
00:20:06,900 --> 00:20:09,440
ఆ మూడు వైపులా ఎందుకంటే
returning-- సామర్థ్యాన్ని కలిగి ఉంటాయి

434
00:20:09,440 --> 00:20:11,647
ఒక చెల్లుబాటు అయ్యే త్రిభుజం సృష్టించే.

435
00:20:11,647 --> 00:20:12,230
అంతే.

436
00:20:12,230 --> 00:20:13,830
మీరు ఇప్పుడు ప్రకటించారు మరియు నిర్వచించిన చేసిన.

437
00:20:13,830 --> 00:20:17,330
మరియు మీరు ఇప్పుడు సామర్థ్యం ఉండవచ్చు
ఉపయోగించడానికి మరియు ఈ ఫంక్షన్ కాల్.

438
00:20:17,330 --> 00:20:19,470
గొప్ప పని.

439
00:20:19,470 --> 00:20:20,650
నేను డౌ లాయిడ్ ఉన్నాను.

440
00:20:20,650 --> 00:20:22,820
ఈ CS50 ఉంది.

441
00:20:22,820 --> 00:20:24,340