1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MACWILLIAM: Mari kita bercakap tentang gelung, salah satu daripada biasa

2
00:00:09,760 --> 00:00:13,380
pengaturcaraan membina kita akan melihat seluruh CS50.

3
00:00:13,380 --> 00:00:15,570
Kami akan menggunakan gelung apabila kita mahu melakukan

4
00:00:15,570 --> 00:00:17,200
tugas yang lebih daripada sekali.

5
00:00:17,200 --> 00:00:20,700
Sebagai contoh, kita mungkin mahu mencetak "hi" 100 kali atau cetak

6
00:00:20,700 --> 00:00:22,700
keluar semua huruf abjad.

7
00:00:22,700 --> 00:00:26,030
Dalam kedua-dua kes ini, kita mempunyai satu perkara yang kami mahu lakukan

8
00:00:26,030 --> 00:00:28,700
beberapa kali, mencetak sesuatu yang keluar.

9
00:00:28,700 --> 00:00:31,970
Walau bagaimanapun, apa yang kita cetak keluar setiap kali boleh berbeza-beza.

10
00:00:31,970 --> 00:00:34,530
Jadi, kita boleh melakukan sesuatu yang sedikit berbeza pada setiap

11
00:00:34,530 --> 00:00:37,820
lelaran, atau berjalan melalui, gelung.

12
00:00:37,820 --> 00:00:41,280
Kita akan melihat tiga jenis gelung dalam C, manakala

13
00:00:41,280 --> 00:00:44,700
gelung, gelung, dan lakukan semasa gelung.

14
00:00:44,700 --> 00:00:47,850
Walaupun ketiga-tiga jenis gelung mempunyai sintaks yang berbeza,

15
00:00:47,850 --> 00:00:50,630
idea-idea yang di belakang mereka adalah sama.

16
00:00:50,630 --> 00:00:53,930
Kami akan menentukan beberapa blok kod dalam pendakap kerinting,

17
00:00:53,930 --> 00:00:57,810
dipanggil badan gelung, yang kita mahu akan dilaksanakan

18
00:00:57,810 --> 00:00:59,790
beberapa beberapa kali.

19
00:00:59,790 --> 00:01:03,370
Dengan menukar nilai pembolehubah yang digunakan di dalam badan, kita

20
00:01:03,370 --> 00:01:07,570
boleh membuat gelung kami melakukan sesuatu yang berbeza setiap kali ia berjalan.

21
00:01:07,570 --> 00:01:10,750
Dengan gelung mana-mana kita menulis, kita juga perlu untuk membuat keputusan apabila

22
00:01:10,750 --> 00:01:12,400
gelung akan berhenti berjalan.

23
00:01:12,400 --> 00:01:15,650
Jika kita tidak berbuat demikian, maka komputer kepercayaan kami akan terus

24
00:01:15,650 --> 00:01:19,040
untuk menjalankan gelung itu sehingga kita membunuh program.

25
00:01:19,040 --> 00:01:22,490
Awal, kita boleh menggunakan ulangan n kali

26
00:01:22,490 --> 00:01:24,600
menyekat untuk mewujudkan gelung.

27
00:01:24,600 --> 00:01:28,200
Semua keping di dalam blok yang berkata berulang 10

28
00:01:28,200 --> 00:01:30,130
akan menjalankan 10 kali.

29
00:01:30,130 --> 00:01:34,160
Dan kemudian, kita akan bergerak kepada keping selepas gelung yang.

30
00:01:34,160 --> 00:01:38,140
Jadi keadaan perhentian kami adalah semata-mata, blok ini telah

31
00:01:38,140 --> 00:01:39,830
menjalankan 10 kali.

32
00:01:39,830 --> 00:01:43,900
Jadi mari kita mencipta ini dalam C. Dalam usaha untuk Gores untuk memastikan

33
00:01:43,900 --> 00:01:46,920
bahawa keping dalam blok berulang dilaksanakan

34
00:01:46,920 --> 00:01:51,180
tepat 10 kali, Gores perlu menjejaki setiap

35
00:01:51,180 --> 00:01:53,750
pelaksanaan blok ulangan.

36
00:01:53,750 --> 00:01:56,790
Untuk menjejaki berapa kali badan gelung kami telah

37
00:01:56,790 --> 00:02:00,360
dilaksanakan, mari kita mewujudkan pemboleh ubah yang dipanggil i.

38
00:02:00,360 --> 00:02:03,400
Kami akan mula i bermula pada sifar, kerana gelung kami

39
00:02:03,400 --> 00:02:04,650
telah tidak dijalankan lagi.

40
00:02:10,009 --> 00:02:10,949
OK

41
00:02:10,949 --> 00:02:15,560
Sekarang kita akan menggunakan kata kunci sementara untuk memulakan gelung kami.

42
00:02:20,100 --> 00:02:24,180
Sekarang kita akan perlu memikirkan apabila gelung kami akan berhenti, tetapi

43
00:02:24,180 --> 00:02:26,730
mari kita meninggalkan ini untuk sekarang dan kemudian kembali kepadanya.

44
00:02:30,970 --> 00:02:32,150
Semua hak.

45
00:02:32,150 --> 00:02:35,260
Dalam gelung kita, mari kita hanya mencetak mesej, seperti

46
00:02:35,260 --> 00:02:38,535
"Hi." Kita boleh menggunakan fungsi printf untuk ini.

47
00:02:48,400 --> 00:02:49,230
Semua hak.

48
00:02:49,230 --> 00:02:54,210
Jadi sekarang kita akan merakam bahawa lelaran badan gelung mempunyai

49
00:02:54,210 --> 00:02:55,750
telah dilaksanakan.

50
00:02:55,750 --> 00:03:00,320
Kita boleh berbuat demikian dengan menambah 1 atau incrementing, kaunter kami

51
00:03:00,320 --> 00:03:01,740
berubah-ubah, i.

52
00:03:01,740 --> 00:03:09,180
Untuk berbuat demikian, kita boleh katakan i sama dengan i campur 1, atau lebih

53
00:03:09,180 --> 00:03:16,520
semata-mata, i campur campur.

54
00:03:16,520 --> 00:03:17,320
Besar.

55
00:03:17,320 --> 00:03:21,810
Jadi sekarang kita dapat melihat bahawa setiap kali gelung kami berjalan, kami

56
00:03:21,810 --> 00:03:24,500
pembolehubah kaunter naik demi satu.

57
00:03:24,500 --> 00:03:29,410
Jadi kita tahu dengan tepat berapa banyak lelaran kita telah dijalankan setakat ini.

58
00:03:29,410 --> 00:03:31,630
Selepas satu lelaran gelung, nilai kita

59
00:03:31,630 --> 00:03:34,270
i akan menjadi 1.

60
00:03:34,270 --> 00:03:37,460
Selepas dua lelaran, i akan 2.

61
00:03:37,460 --> 00:03:42,640
Dan selepas 10 lelaran, i akan menjadi 10.

62
00:03:42,640 --> 00:03:46,780
Jadi, jika kita mahu untuk menjalankan gelung ini tepat 10 kali, maka

63
00:03:46,780 --> 00:03:49,240
ini adalah apabila kita mahu berhenti.

64
00:03:49,240 --> 00:03:53,860
Jadi kita mahu untuk menjalankan gelung ini manakala i adalah kurang daripada 10, dan

65
00:03:53,860 --> 00:03:57,630
itulah apa yang kita akan menulis, manakala i

66
00:03:57,630 --> 00:04:02,450
adalah kurang daripada 10.

67
00:04:02,450 --> 00:04:06,380
Keadaan ini kelihatan seperti keadaan kita digunakan dalam jika

68
00:04:06,380 --> 00:04:07,830
blok lain.

69
00:04:07,830 --> 00:04:11,690
Selepas badan gelung kami telah dilaksanakan, program kami

70
00:04:11,690 --> 00:04:14,690
akan melompat kembali kepada keadaan gelung.

71
00:04:14,690 --> 00:04:17,290
Jika keadaan ini benar, maka badan

72
00:04:17,290 --> 00:04:18,990
gelung akan dijalankan lagi.

73
00:04:18,990 --> 00:04:22,190
Jika keadaan ini tidak lagi benar, maka gelung kami tidak akan

74
00:04:22,190 --> 00:04:25,700
berlari lagi dan akan bergerak ke baris seterusnya kod

75
00:04:25,700 --> 00:04:27,876
bawah gelung kami.

76
00:04:27,876 --> 00:04:28,550
Semua hak.

77
00:04:28,550 --> 00:04:30,740
Jadi mari kita melihat kedua jenis

78
00:04:30,740 --> 00:04:33,000
gelung, untuk gelung.

79
00:04:33,000 --> 00:04:37,310
Seterusnya kata kunci sementara, dalam kurungan, kita mempunyai satu perkara,

80
00:04:37,310 --> 00:04:39,840
keadaan yang diperlukan untuk menjadi benar bagi

81
00:04:39,840 --> 00:04:42,010
badan gelung untuk dilaksanakan.

82
00:04:42,010 --> 00:04:45,440
Itu bermakna kita terpaksa untuk mencipta pembolehubah kaunter kami di luar

83
00:04:45,440 --> 00:04:48,760
gelung dan ingat untuk kenaikan pada satu ketika

84
00:04:48,760 --> 00:04:51,050
di dalam gelung.

85
00:04:51,050 --> 00:04:54,320
Pengepala untuk kami untuk gelung, di sisi lain, mempunyai tiga

86
00:04:54,320 --> 00:04:58,510
bahagian, masing-masing yang akan dipisahkan dengan koma bernoktah.

87
00:04:58,510 --> 00:05:01,950
Di tempat ketiga pertama kita, kita boleh mengisytiharkan mana-mana kaunter atau penolong

88
00:05:01,950 --> 00:05:05,000
pembolehubah yang kita ingin gunakan dalam gelung kami.

89
00:05:05,000 --> 00:05:07,350
Dalam amalan, ini boleh menjadi benar-benar membantu.

90
00:05:07,350 --> 00:05:10,590
Kami benar-benar tidak perlu yang berubah-ubah, saya, selepas beberapa ketika kami

91
00:05:10,590 --> 00:05:13,650
gelung telah dijalankan, jadi kita benar-benar tidak perlu perlu mengisytiharkan

92
00:05:13,650 --> 00:05:15,810
luar gelung.

93
00:05:15,810 --> 00:05:19,080
Ketiga kedua akan menjadi keadaan yang mesti benar

94
00:05:19,080 --> 00:05:21,850
untuk badan akan dilaksanakan sekali lagi, sama seperti

95
00:05:21,850 --> 00:05:23,330
dalam gelung sementara kami.

96
00:05:23,330 --> 00:05:26,350
Di tempat ketiga terakhir kami, kami boleh menjalankan kenyataan yang akan

97
00:05:26,350 --> 00:05:30,270
dilaksanakan selepas setiap lelaran gelung, jadi kita tidak mempunyai

98
00:05:30,270 --> 00:05:32,710
untuk membina ia ke dalam badan gelung.

99
00:05:32,710 --> 00:05:38,390
Jadi, mari kita menulis untuk gelung yang mengira detik 5-1.

100
00:05:38,390 --> 00:05:41,790
Kami akan bermula dengan kata kunci untuk.

101
00:05:41,790 --> 00:05:44,680
Kita boleh mewujudkan pembolehubah kaunter pertama, yang kami akan

102
00:05:44,680 --> 00:05:47,840
ditetapkan kepada 5 masa ini kerana kami mengira turun,

103
00:05:47,840 --> 00:05:50,110
diikuti oleh koma bernoktah.

104
00:05:50,110 --> 00:05:53,660
Berikut adalah keadaan kita, yang kita akan kembali ke sini.

105
00:05:53,660 --> 00:05:57,540
Ketiga, kita ingin susutan pembolehubah kaunter kami selepas

106
00:05:57,540 --> 00:05:59,620
setiap lelaran gelung.

107
00:05:59,620 --> 00:06:04,740
Jadi, bukannya mengatakan i campur campur, kita akan berkata i tolak tolak.

108
00:06:04,740 --> 00:06:05,300
Semua hak.

109
00:06:05,300 --> 00:06:09,490
Jadi kita mahu badan gelung untuk menjalankan semasa i masih

110
00:06:09,490 --> 00:06:11,960
lebih besar daripada 0.

111
00:06:11,960 --> 00:06:16,160
Dalam badan gelung, mari kita mencetak nilai i.

112
00:06:16,160 --> 00:06:20,480
Untuk berbuat demikian, kami akan menggunakan fungsi printf, menggunakan d%

113
00:06:20,480 --> 00:06:21,650
placeholder.

114
00:06:21,650 --> 00:06:24,820
Ingat, pemegang tempat yang akan digantikan dengan

115
00:06:24,820 --> 00:06:27,040
nilai i.

116
00:06:27,040 --> 00:06:32,060
Akhirnya, mari kita menambah satu kenyataan selepas kami untuk gelung.

117
00:06:32,060 --> 00:06:35,850
Apabila kita menjalankan gelung ini, saya akan bermula pada 5,

118
00:06:35,850 --> 00:06:38,070
jadi 5 akan dicetak.

119
00:06:38,070 --> 00:06:42,000
Sekali i sampai kepada 0, keadaan kesinambungan, i

120
00:06:42,000 --> 00:06:44,450
lebih besar daripada 0, tidak lagi akan memegang.

121
00:06:44,450 --> 00:06:47,330
Jadi gelung kami akan berhenti melaksanakan, dan kita akan melihat

122
00:06:47,330 --> 00:06:49,850
penyata selepas gelung.

123
00:06:49,850 --> 00:06:51,340
Jadi mari kita menjalankan kod ini.

124
00:06:51,340 --> 00:06:52,700
Pertama, kita akan menyusun

125
00:06:52,700 --> 00:06:56,460
countdown.c dengan membuat undur.

126
00:06:56,460 --> 00:06:59,320
Sekarang, kita boleh menjalankan kod ini. Undur /.

127
00:07:02,340 --> 00:07:06,040
Dalam kedua-dua gelung sementara dan untuk gelung, kami kesinambungan

128
00:07:06,040 --> 00:07:09,010
keadaan akan diperiksa sebelum badan

129
00:07:09,010 --> 00:07:10,960
gelung dilaksanakan.

130
00:07:10,960 --> 00:07:13,840
Ini bermaksud bahawa, jika keadaan kita tidak mulanya

131
00:07:13,840 --> 00:07:18,100
benar, maka badan gelung kami tidak akan dijalankan.

132
00:07:18,100 --> 00:07:22,060
Jadi ia kadang-kadang berguna untuk memeriksa keadaan selepas

133
00:07:22,060 --> 00:07:25,150
badan gelung bukannya sebelum ia.

134
00:07:25,150 --> 00:07:28,270
Jadi mari kita menulis gelung untuk meminta pengguna untuk nombor

135
00:07:28,270 --> 00:07:30,990
sehingga nombor positif dibekalkan.

136
00:07:30,990 --> 00:07:34,740
Jika pengguna input nombor negatif, kita akan mahu untuk bertanya kepada mereka

137
00:07:34,740 --> 00:07:36,260
bagi nombor lain.

138
00:07:36,260 --> 00:07:38,940
Jadi kita akan mahu ini segera untuk berada di dalam

139
00:07:38,940 --> 00:07:41,050
badan luar gelung.

140
00:07:41,050 --> 00:07:44,730
Walau bagaimanapun, apabila gelung dijalankan buat kali pertama, pengguna

141
00:07:44,730 --> 00:07:46,750
telah tidak memberikan kita nombor lagi.

142
00:07:46,750 --> 00:07:49,640
Supaya ia tidak masuk akal untuk memeriksa jika ia adalah positif.

143
00:07:49,640 --> 00:07:54,020
Sebaliknya, kita akan mahu untuk memeriksa nombor selepas badan

144
00:07:54,020 --> 00:07:55,720
gelung dijalankan.

145
00:07:55,720 --> 00:08:00,310
Kita boleh melakukan ini dengan do gelung while.

146
00:08:00,310 --> 00:08:03,560
Pertama, kita akan mewujudkan pemboleh ubah, n, yang akan memegang

147
00:08:03,560 --> 00:08:05,230
input pengguna.

148
00:08:05,230 --> 00:08:09,960
Sekarang kita akan menggunakan kata kunci do, diikuti oleh pendakap kerinting bahawa

149
00:08:09,960 --> 00:08:12,930
akan bermula badan gelung kami.

150
00:08:12,930 --> 00:08:16,230
Dalam badan, kita boleh mendorong pengguna untuk beberapa dengan

151
00:08:16,230 --> 00:08:18,480
GetInt berfungsi.

152
00:08:18,480 --> 00:08:23,230
Sekarang, kita akan mahu badan gelung ini untuk melaksanakan sekali lagi jika

153
00:08:23,230 --> 00:08:28,370
pengguna menaip nombor negatif, jadi kita akan mengatakan manakala n

154
00:08:28,370 --> 00:08:30,420
adalah kurang daripada 0.

155
00:08:30,420 --> 00:08:33,140
Notis koma bernoktah di sini selepas kenyataan manakala.

156
00:08:38,909 --> 00:08:40,679
Jadi mari kita menjalankan kod ini.

157
00:08:40,679 --> 00:08:44,780
Pertama, kita akan menyusun ini dengan membuat positif.

158
00:08:44,780 --> 00:08:49,340
Sekarang kita boleh menjalankan program. / Positif.

159
00:08:49,340 --> 00:08:52,660
Jika kita memberikan program ini nombor negatif, seperti negatif

160
00:08:52,660 --> 00:08:56,560
4, maka kita akan diminta sekali lagi untuk beberapa sejak

161
00:08:56,560 --> 00:09:00,490
keadaan buat kami gelung while adalah benar.

162
00:09:00,490 --> 00:09:04,690
Apabila kita memberikan nombor positif, seperti 8, maka

163
00:09:04,690 --> 00:09:08,560
keadaan do kami gelung while tidak lagi akan menjadi kenyataan.

164
00:09:08,560 --> 00:09:12,080
Jadi gelung tidak akan dilaksanakan lagi.

165
00:09:12,080 --> 00:09:15,290
Dan itu bagi tiga jenis gelung kita akan menggunakan di C.

166
00:09:15,290 --> 00:09:18,840
Nama saya adalah Tommy, dan ini adalah CS50.