1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MACWILLIAM: Разговор Ајде за петелки, еден од заедничките

2
00:00:09,760 --> 00:00:13,380
програмски конструкции ќе видиме во текот CS50.

3
00:00:13,380 --> 00:00:15,570
Ќе искористиме петелки кога сакаме да се изврши

4
00:00:15,570 --> 00:00:17,200
задача повеќе од еднаш.

5
00:00:17,200 --> 00:00:20,700
На пример, ние можеби ќе сакате да се печати "Здраво" 100 пати печати или

6
00:00:20,700 --> 00:00:22,700
од сите букви од азбуката.

7
00:00:22,700 --> 00:00:26,030
Во двата од овие случаи, имаме едно нешто што сакате да го направите

8
00:00:26,030 --> 00:00:28,700
неколку пати, печати нешто надвор.

9
00:00:28,700 --> 00:00:31,970
Сепак, она што ние го испечатите секој пат може да се разликуваат.

10
00:00:31,970 --> 00:00:34,530
Значи можеме да направиме нешто малку различни на секој

11
00:00:34,530 --> 00:00:37,820
повторување, или ја извршите преку, на јамка.

12
00:00:37,820 --> 00:00:41,280
Ќе видиме три различни видови на јамки во C, додека

13
00:00:41,280 --> 00:00:44,700
петелки, за петелки, и направи додека петелки.

14
00:00:44,700 --> 00:00:47,850
Иако овие три вида на јамки имаат различни синтакса,

15
00:00:47,850 --> 00:00:50,630
идеите зад нив се исти.

16
00:00:50,630 --> 00:00:53,930
Ние ќе дефинираме некои блок од код во големи загради,

17
00:00:53,930 --> 00:00:57,810
нарекува тело на јамка, дека ние сакаме да се изврши

18
00:00:57,810 --> 00:00:59,790
одреден број на пати.

19
00:00:59,790 --> 00:01:03,370
Со менување на вредностите на променливите се користат во телото, ние

20
00:01:03,370 --> 00:01:07,570
да ја направиме нашата јамка се направи нешто различно секој пат кога се работи.

21
00:01:07,570 --> 00:01:10,750
Со било јамка ние пишуваме, ние исто така ќе треба да одлучи кога на

22
00:01:10,750 --> 00:01:12,400
јамка ќе престане да работи.

23
00:01:12,400 --> 00:01:15,650
Ако ние не го сторат тоа, тогаш нашите сигурен компјутер ќе продолжи

24
00:01:15,650 --> 00:01:19,040
да се кандидира тој јамка се додека не го убијат програма.

25
00:01:19,040 --> 00:01:22,490
Во гребење, ние може да го користи повтори n пати

26
00:01:22,490 --> 00:01:24,600
блокира за да се создаде еден циклус.

27
00:01:24,600 --> 00:01:28,200
Сите парчиња во внатрешноста на блок што рече повтори 10

28
00:01:28,200 --> 00:01:30,130
ќе биде извршена 10 пати.

29
00:01:30,130 --> 00:01:34,160
И тогаш, ние ќе се движи кон парчиња после тоа јамка.

30
00:01:34,160 --> 00:01:38,140
Па нашите гости состојба е едноставно, овој блок е

31
00:01:38,140 --> 00:01:39,830
работи 10 пати.

32
00:01:39,830 --> 00:01:43,900
Значи, да креираме во C. Во цел за нула да се обезбеди

33
00:01:43,900 --> 00:01:46,920
дека парчиња во рамките на повтори блок се извршуваат

34
00:01:46,920 --> 00:01:51,180
точно 10 пати, гребење треба да ги пратите на секоја

35
00:01:51,180 --> 00:01:53,750
извршувањето на повтори блок.

36
00:01:53,750 --> 00:01:56,790
Да ги пратите на тоа колку пати нашата јамка тело е

37
00:01:56,790 --> 00:02:00,360
извршува, да се создаде променлива наречена i.

38
00:02:00,360 --> 00:02:03,400
Ќе ми започнете на нула, бидејќи нашите јамка

39
00:02:03,400 --> 00:02:04,650
не се извршува уште.

40
00:02:10,009 --> 00:02:10,949
Ред

41
00:02:10,949 --> 00:02:15,560
Сега ќе го користите додека клучни зборови за да започнете нашите јамка.

42
00:02:20,100 --> 00:02:24,180
Сега ќе треба да дознаам кога нашите јамка ќе престане, но

43
00:02:24,180 --> 00:02:26,730
ајде да ја напушти оваа сега за сега, а потоа се врати на неа.

44
00:02:30,970 --> 00:02:32,150
Во ред.

45
00:02:32,150 --> 00:02:35,260
Внатрешноста на нашата телефонска линија, ајде да печати порака надвор, како

46
00:02:35,260 --> 00:02:38,535
"Здраво". Можеме да го користите printf функцијата за ова.

47
00:02:48,400 --> 00:02:49,230
Во ред.

48
00:02:49,230 --> 00:02:54,210
Па сега ние ќе ги сними дека повторување на јамка тело има

49
00:02:54,210 --> 00:02:55,750
е извршена.

50
00:02:55,750 --> 00:03:00,320
Ние можеме да го направите тоа со додавање на 1 до, или зголемување,, нашите counter

51
00:03:00,320 --> 00:03:01,740
променлива, з.

52
00:03:01,740 --> 00:03:09,180
Да го стори тоа, можеме да кажеме i е еднаква на i плус 1 или повеќе

53
00:03:09,180 --> 00:03:16,520
едноставно, јас плус плус.

54
00:03:16,520 --> 00:03:17,320
Велики.

55
00:03:17,320 --> 00:03:21,810
Па сега можеме да видиме дека секој пат кога нашите јамка се кандидира, нашите

56
00:03:21,810 --> 00:03:24,500
counter променлива оди по еден.

57
00:03:24,500 --> 00:03:29,410
Па знаеме точно колку повторувања ние ја стартувате досега.

58
00:03:29,410 --> 00:03:31,630
По една повторување на јамка, нашата вредност

59
00:03:31,630 --> 00:03:34,270
на i ќе биде 1.

60
00:03:34,270 --> 00:03:37,460
По две повторувања, јас ќе бидам 2.

61
00:03:37,460 --> 00:03:42,640
И по 10 повторувања, јас ќе бидам 10.

62
00:03:42,640 --> 00:03:46,780
Значи, ако сакаме да ја извршите оваа јамка точно 10 пати, а потоа

63
00:03:46,780 --> 00:03:49,240
ова е кога сакаме да запре.

64
00:03:49,240 --> 00:03:53,860
Затоа сакаме да ја извршите оваа јамка додека i е помал од 10, и

65
00:03:53,860 --> 00:03:57,630
тоа е токму она што ќе пишувам, а јас

66
00:03:57,630 --> 00:04:02,450
е помал од 10.

67
00:04:02,450 --> 00:04:06,380
Оваа состојба изгледа како и условите што се користи во ако

68
00:04:06,380 --> 00:04:07,830
друго блокови.

69
00:04:07,830 --> 00:04:11,690
По телото на нашиот јамка е извршена, нашата програма

70
00:04:11,690 --> 00:04:14,690
ќе скокне назад до состојба петелки.

71
00:04:14,690 --> 00:04:17,290
Ако условот е исполнет, а потоа телото на

72
00:04:17,290 --> 00:04:18,990
јамка ќе се кандидира повторно.

73
00:04:18,990 --> 00:04:22,190
Доколку условот не е точно, тогаш нашата телефонска линија нема да биде

74
00:04:22,190 --> 00:04:25,700
работат повеќе и ќе се движи кон следната линија код

75
00:04:25,700 --> 00:04:27,876
под нашите јамка.

76
00:04:27,876 --> 00:04:28,550
Во ред.

77
00:04:28,550 --> 00:04:30,740
Па ајде да ги разгледаме во втор вид на

78
00:04:30,740 --> 00:04:33,000
циклус, за телефонска линија.

79
00:04:33,000 --> 00:04:37,310
До додека клучен збор, во загради, имавме една работа,

80
00:04:37,310 --> 00:04:39,840
услов потребен за да биде вистина за

81
00:04:39,840 --> 00:04:42,010
јамка тело да се кандидира.

82
00:04:42,010 --> 00:04:45,440
Тоа значи дека моравме да се создаде нашиот counter променлива надвор

83
00:04:45,440 --> 00:04:48,760
на јамка и не заборавајте да го зголемување во одреден момент

84
00:04:48,760 --> 00:04:51,050
внатрешноста на јамка.

85
00:04:51,050 --> 00:04:54,320
Насловот за нашите за телефонска линија, од друга страна, има три

86
00:04:54,320 --> 00:04:58,510
делови, од кои секоја ќе бидат одделени со точка-запирка.

87
00:04:58,510 --> 00:05:01,950
Во нашата прва третина, ние да се прогласиме за секој шалтер или helper

88
00:05:01,950 --> 00:05:05,000
променливи ние би сакале да ја користат во нашиот јамка.

89
00:05:05,000 --> 00:05:07,350
Во пракса, ова може да биде навистина корисно.

90
00:05:07,350 --> 00:05:10,590
Ние навистина не треба таа променлива, јас, по нашето време

91
00:05:10,590 --> 00:05:13,650
јамка е подигнат, па ние навистина не треба да се изјасни

92
00:05:13,650 --> 00:05:15,810
надвор од јамка.

93
00:05:15,810 --> 00:05:19,080
Втората третина ќе биде услов што мора да биде вистина

94
00:05:19,080 --> 00:05:21,850
за телото да се изврши повторно, исто како

95
00:05:21,850 --> 00:05:23,330
во нашата додека јамка.

96
00:05:23,330 --> 00:05:26,350
Во нашата последна третина, ние може да работи изјава дека ќе биде

97
00:05:26,350 --> 00:05:30,270
егзекутирани по секоја повторување на јамка, па ние немаме

98
00:05:30,270 --> 00:05:32,710
да го изгради во јамка тело.

99
00:05:32,710 --> 00:05:38,390
Значи, да се напише за јамка што се брои надолу 5-1.

100
00:05:38,390 --> 00:05:41,790
Ќе започнеме со за клучниот збор.

101
00:05:41,790 --> 00:05:44,680
Ние можеме да создадеме контра променлива Првиот, кој ние ќе

102
00:05:44,680 --> 00:05:47,840
постави до 5 овој пат бидејќи ние сме броење надолу,

103
00:05:47,840 --> 00:05:50,110
проследено со запирка.

104
00:05:50,110 --> 00:05:53,660
Следна е нашата состојба, која ќе се врати на.

105
00:05:53,660 --> 00:05:57,540
Трето, ние би сакале да декриминирачките нашите counter променлива по

106
00:05:57,540 --> 00:05:59,620
секој повторување на јамка.

107
00:05:59,620 --> 00:06:04,740
Така, наместо велејќи i плус плус, ние ќе кажам јас минус минус.

108
00:06:04,740 --> 00:06:05,300
Во ред.

109
00:06:05,300 --> 00:06:09,490
Затоа сакаме јамка тело да се кандидира додека јас се уште

110
00:06:09,490 --> 00:06:11,960
поголем од 0.

111
00:06:11,960 --> 00:06:16,160
Во телото на циклусот, да испечатите на вредноста на i.

112
00:06:16,160 --> 00:06:20,480
Да го стори тоа, ние ќе го користите printf функцијата, со користење на% d

113
00:06:20,480 --> 00:06:21,650
случаеви.

114
00:06:21,650 --> 00:06:24,820
Запомнете, дека случаеви ќе биде заменет со

115
00:06:24,820 --> 00:06:27,040
вредноста на i.

116
00:06:27,040 --> 00:06:32,060
Конечно, да додадете изјава по нашите за телефонска линија.

117
00:06:32,060 --> 00:06:35,850
Кога ќе ја извршите оваа линија, јас ќе започнете во 5,

118
00:06:35,850 --> 00:06:38,070
па 5 ќе бидат испечатени.

119
00:06:38,070 --> 00:06:42,000
Еднаш се добива на 0, продолжување состојба, i е

120
00:06:42,000 --> 00:06:44,450
поголема од 0, повеќе нема да се одржи.

121
00:06:44,450 --> 00:06:47,330
Значи, нашата телефонска линија ќе престане извршување, и ние ќе ја видите

122
00:06:47,330 --> 00:06:49,850
изјава по јамка.

123
00:06:49,850 --> 00:06:51,340
Па ајде да ја извршите оваа код.

124
00:06:51,340 --> 00:06:52,700
Прво, ние ќе состави

125
00:06:52,700 --> 00:06:56,460
countdown.c со направи одбројувањето.

126
00:06:56,460 --> 00:06:59,320
Сега, ние може да работи овој код со. / Одбројувањето.

127
00:07:02,340 --> 00:07:06,040
Во двата додека петелките и за петелки, нашата продолжување

128
00:07:06,040 --> 00:07:09,010
состојба ќе бидат проверени пред телото

129
00:07:09,010 --> 00:07:10,960
од циклусот се извршува.

130
00:07:10,960 --> 00:07:13,840
Тоа значи дека, ако нашата состојба не е првично

131
00:07:13,840 --> 00:07:18,100
точно, тогаш телото на нашиот јамка никогаш нема да се кандидира.

132
00:07:18,100 --> 00:07:22,060
Така, тоа е понекогаш е корисно да се провери состојбата по

133
00:07:22,060 --> 00:07:25,150
Телото на циклусот, а не пред тоа.

134
00:07:25,150 --> 00:07:28,270
Значи, да напише циклус да го извести корисникот за голем број

135
00:07:28,270 --> 00:07:30,990
до позитивен број се доставени.

136
00:07:30,990 --> 00:07:34,740
Ако корисникот влезови негативен број, ќе сакате да ги прашате

137
00:07:34,740 --> 00:07:36,260
за друг број.

138
00:07:36,260 --> 00:07:38,940
Па ние ќе го сакате ова брзо да се биде внатре во

139
00:07:38,940 --> 00:07:41,050
тело надвор од јамка.

140
00:07:41,050 --> 00:07:44,730
Меѓутоа, кога јамка се кандидира за прв пат, на корисникот

141
00:07:44,730 --> 00:07:46,750
не ни даде бројот сеуште.

142
00:07:46,750 --> 00:07:49,640
Па тоа не дава никаква смисла да се провери дали тоа е позитивно.

143
00:07:49,640 --> 00:07:54,020
Наместо тоа, ние ќе сакате да се провери бројот по телото на

144
00:07:54,020 --> 00:07:55,720
јамка се работи.

145
00:07:55,720 --> 00:08:00,310
Ние можеме да го направите ова со направи додека јамка.

146
00:08:00,310 --> 00:08:03,560
Прво, ние ќе се создаде променлива, n, што ќе се одржи

147
00:08:03,560 --> 00:08:05,230
на корисникот влез.

148
00:08:05,230 --> 00:08:09,960
Сега ќе го користите Дали клучни зборови, проследено со кадрави загради дека

149
00:08:09,960 --> 00:08:12,930
ќе започнете телото на нашиот јамка.

150
00:08:12,930 --> 00:08:16,230
Во телото, може да го извести корисникот за број со

151
00:08:16,230 --> 00:08:18,480
GetInt функција.

152
00:08:18,480 --> 00:08:23,230
Сега, ние ќе сакаат телото на овој циклус да се изврши повторно, ако

153
00:08:23,230 --> 00:08:28,370
корисникот внесе негативен број, па ние ќе каже додека n

154
00:08:28,370 --> 00:08:30,420
е помал од 0.

155
00:08:30,420 --> 00:08:33,140
Забележите запирка тука по време соопштението.

156
00:08:38,909 --> 00:08:40,679
Па ајде да ја извршите оваа код.

157
00:08:40,679 --> 00:08:44,780
Прво, ние ќе ги собере со направи позитивен.

158
00:08:44,780 --> 00:08:49,340
Сега можеме да ја стартувате програмата со. / Позитивен.

159
00:08:49,340 --> 00:08:52,660
Ако се даде оваа програма негативен број, како негативен

160
00:08:52,660 --> 00:08:56,560
4, тогаш ќе биде побарано повторно за голем број од

161
00:08:56,560 --> 00:09:00,490
состојбата на нашата направите додека јамка е вистина.

162
00:09:00,490 --> 00:09:04,690
Откако ќе даде позитивен број, како 8, тогаш

163
00:09:04,690 --> 00:09:08,560
состојбата на нашата направите додека јамка повеќе нема да биде точно.

164
00:09:08,560 --> 00:09:12,080
Па јамка нема да се изврши повторно.

165
00:09:12,080 --> 00:09:15,290
И тоа е тоа за три вида на јамки ние ќе ги користат во C.

166
00:09:15,290 --> 00:09:18,840
Моето име е Томи, и ова е CS50.