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
loop θα σταματήσει να λειτουργεί.

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
Το Scratch, θα μπορούσαμε να χρησιμοποιήσουμε την επανάληψη 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. Για να εξασφαλιστεί Scratch

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, ή προσαύξηση, μετρητής μας

51
00:03:00,320 --> 00:03:01,740
μεταβλητή, i.

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
μεταβλητή μετρητή ανεβαίνει κατά ένα.

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
loop θα τρέξει ξανά.

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
βρόχο, ο βρόχος for.

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
Αυτό σημαίνει ότι έπρεπε να δημιουργήσουμε μετρητή μεταβλητή μας έξω

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
Στο πρώτο τρίτο μας, μπορούμε να δηλώσουμε οποιοδήποτε μετρητή ή βοηθός

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
Πραγματικά δεν χρειάζεται αυτή τη μεταβλητή, i, ενώ μετά μας

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
Τρίτον, θα θέλαμε να μειώσετε μετρητή μεταβλητή μας μετά

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
Έτσι θέλουμε το σώμα βρόχο για να τρέξει, ενώ εξακολουθεί να είναι i

110
00:06:09,490 --> 00:06:11,960
μεγαλύτερη από μηδέν.

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
Μπορούμε να το κάνουμε αυτό με ένα do while loop.

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
Τώρα θα χρησιμοποιήσουμε τη λέξη-κλειδί do, που ακολουθείται από άγκιστρα που

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
είναι μικρότερο από μηδέν.

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
κατάσταση του do μας, ενώ βρόχο ήταν αλήθεια.

162
00:09:00,490 --> 00:09:04,690
Μόλις έχουμε δώσει ένα θετικό αριθμό, όπως και 8, τότε η

163
00:09:04,690 --> 00:09:08,560
κατάσταση του do while loop μας δεν θα είναι πλέον να είναι αλήθεια.

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
Το όνομά μου είναι ο Tommy, και αυτό είναι CS50.