1
00:00:00,000 --> 00:00:05,410

2
00:00:05,410 --> 00:00:07,640
>> DOUG LLOYD: Εντάξει, έτσι
ας μιλήσουμε για βρόχους.

3
00:00:07,640 --> 00:00:10,015
Έτσι βρόχοι είναι είδος δροσερό
επειδή επιτρέπουν το πρόγραμμά σας

4
00:00:10,015 --> 00:00:12,050
για την εκτέλεση γραμμές κώδικα
ξανά και ξανά και ξανά.

5
00:00:12,050 --> 00:00:15,600
Επανειλημμένα, χωρίς να χρειάζεται να αντιγράψετε
και να επικολλήσετε ή αλλιώς επαναλάβετε τους.

6
00:00:15,600 --> 00:00:17,630
Υπάρχουν τρεις μεγάλες
τα είδη των βρόχων που θα δείτε.

7
00:00:17,630 --> 00:00:21,010
Θα πρέπει πιθανώς ευκαιρία για να χρησιμοποιήσει
ο καθένας, όπως σας πρόοδος μέσω CS50.

8
00:00:21,010 --> 00:00:22,940
Μερικά από αυτά τα κυκλώματα είναι αρκετά
γνωστά σε σας από το μηδέν,

9
00:00:22,940 --> 00:00:25,814
οπότε και πάλι, όπως κάναμε με υποθετικά,
θα τους θέσει ένα δίπλα στο άλλο

10
00:00:25,814 --> 00:00:28,930
αν υπάρχει μια αναλογία μπορούμε να αντλήσουμε.

11
00:00:28,930 --> 00:00:33,600
>> Πρώτη είναι για πάντα από το μηδέν,
η οποία συγκρίνει με while (true).

12
00:00:33,600 --> 00:00:35,390
Αυτό είναι αυτό που λέμε ένα άπειρο βρόχο.

13
00:00:35,390 --> 00:00:38,560
Οι γραμμές του κώδικα μεταξύ των σγουρά
τιράντες, όπως και τα κομμάτια του παζλ

14
00:00:38,560 --> 00:00:41,190
ότι ταιριάζει στο εσωτερικό του C
από το μπλοκ για πάντα,

15
00:00:41,190 --> 00:00:45,290
θα εκτελέσει επανειλημμένα από την κορυφή
προς τα κάτω, ξανά και ξανά και ξανά,

16
00:00:45,290 --> 00:00:46,085
για πάντα.

17
00:00:46,085 --> 00:00:48,710
Μετά από όλα, αν θυμάστε μας
συζήτηση των Boolean εκφράσεις,

18
00:00:48,710 --> 00:00:51,060
αλήθεια είναι πάντα αλήθεια.

19
00:00:51,060 --> 00:00:53,250
Έτσι, αν κάνουμε
κάτι τόσο καιρό, όπως ισχύει

20
00:00:53,250 --> 00:00:58,227
είναι αυτό true-- φαίνεται λίγο silly-- αλήθεια
είναι πάντα αλήθεια, γι 'αυτό θα τρέξει πάντα.

21
00:00:58,227 --> 00:01:00,060
Θα τρέξει για πάντα και
ποτέ και ποτέ μέχρι να

22
00:01:00,060 --> 00:01:02,900
βρούμε έναν τρόπο για να ξεφύγει από αυτό με
μια δήλωση διάλειμμα, η οποία και πάλι,

23
00:01:02,900 --> 00:01:06,350
είδαμε πριν από λίγο καιρό εμείς
μιλούσαν για αλλαγή.

24
00:01:06,350 --> 00:01:08,725
>> Ή αλλιώς σκοτώνουν απλώς μας
πρόγραμμα, το οποίο παρεμπιπτόντως,

25
00:01:08,725 --> 00:01:11,110
αν ποτέ βρεθείτε σε ένα
κατάσταση με ατέρμονα βρόχο

26
00:01:11,110 --> 00:01:13,484
και δεν ξέρετε πώς να σταματήσει
το πρόγραμμά σας από το τρέξιμο.

27
00:01:13,484 --> 00:01:16,527
Απλά πατήστε ελέγχου και C και
ότι θα σκοτώσει το πρόγραμμά σας για σας.

28
00:01:16,527 --> 00:01:18,360
Αλλά αυτό, πάλι, είναι
ονομάζεται ένας άπειρος βρόχος.

29
00:01:18,360 --> 00:01:19,818
Είναι ένας βρόχος που θα τρέχει για πάντα.

30
00:01:19,818 --> 00:01:22,570

31
00:01:22,570 --> 00:01:25,610
Τώρα, ενώ οι βρόχοι δεν είναι
πάντα άπειρο, γιατί επίσης

32
00:01:25,610 --> 00:01:27,880
μπορούμε να αντικαταστήσουμε το Boolean
έκφρασης με κάτι

33
00:01:27,880 --> 00:01:29,867
λίγο πιο χρήσιμο από μόνο αληθινό.

34
00:01:29,867 --> 00:01:30,950
Έτσι, εδώ είναι ένα άλλο παράδειγμα.

35
00:01:30,950 --> 00:01:34,600
Ενώ και κάποια Boolean
έκφρασης και στη συνέχεια άγκιστρα.

36
00:01:34,600 --> 00:01:38,310
Αυτό είναι λίγο πολύ ανάλογο
να επαναλάβετε μέχρι, από το μηδέν.

37
00:01:38,310 --> 00:01:40,700
Αν και σε ένα δεύτερο, θα
εξηγήσει τη διαφορά.

38
00:01:40,700 --> 00:01:44,310
>> Έτσι σε C, εάν η λογική έκφραση
στο εσωτερικό του βρόχου while

39
00:01:44,310 --> 00:01:47,980
είναι αληθής, τις γραμμές
Κωδικός μεταξύ των άγκιστρα

40
00:01:47,980 --> 00:01:51,900
θα εκτελέσει επανειλημμένα ξανά και ξανά
και ξανά μέχρι Boolean έκφραση

41
00:01:51,900 --> 00:01:55,174
ψευδής.

42
00:01:55,174 --> 00:01:57,340
Έτσι, για παράδειγμα, μπορεί να
έχουν κάποιο είδος του μετρητή.

43
00:01:57,340 --> 00:02:01,440
Έτσι που λέτε στην αρχή
Αυτός ο βρόχος λένε int x ισούται με μηδέν.

44
00:02:01,440 --> 00:02:06,370
Ενώ το x είναι μικρότερο από 100, να κάνει μια-δυο
τα πράγματα μέσα σε αυτό το άγκιστρα,

45
00:02:06,370 --> 00:02:10,570
στη συνέχεια, στο τέλος του βρόχου σας, λέτε
x συν συν, εσείς προσαύξηση x.

46
00:02:10,570 --> 00:02:13,360
Τελικά x θα πάρει
σε 100 και θα σας

47
00:02:13,360 --> 00:02:15,760
να σταματήσει επειδή η κατάσταση
το χ είναι μικρότερο από 100

48
00:02:15,760 --> 00:02:19,416
δεν θα είναι πλέον αλήθεια, όπως
Μόλις x είναι ίσο με 100.

49
00:02:19,416 --> 00:02:21,820
100 δεν είναι μικρότερη από 100.

50
00:02:21,820 --> 00:02:25,870
>> Τώρα κάπως συγκεχυμένα, η συμπεριφορά
του μπλοκ μηδέν αντιστρέφεται.

51
00:02:25,870 --> 00:02:29,110
Γι 'αυτό να είστε πολύ προσεκτικοί αν αυτό είναι
πρώτη επιδρομή στη χρήση βρόχων.

52
00:02:29,110 --> 00:02:33,630
Βασικά, η επανάληψη
μέχρι το μπλοκ στο Ξυστό

53
00:02:33,630 --> 00:02:35,970
Θα επαναλάβω κάτι
ξανά και ξανά και ξανά,

54
00:02:35,970 --> 00:02:40,460
μέχρι την έκφραση, το Boolean
έκφραση στο εξάγωνο είναι αλήθεια.

55
00:02:40,460 --> 00:02:43,860
Γι 'αυτό θα συνεχίσουμε να κάνουμε
μέχρι να είναι αλήθεια.

56
00:02:43,860 --> 00:02:48,881
Εν τω μεταξύ, το βρόχο while θα
να συνεχίσει να το κάνει μέχρι να είναι ψευδής.

57
00:02:48,881 --> 00:02:51,630
Έτσι είναι αρκετά παρόμοια, αλλά
υπάρχει αυτό το μικρό διάκριση μόνο

58
00:02:51,630 --> 00:02:55,140
να είστε προσεκτικοί ιδιαίτερα, όπως κάνετε
πρώτη επιδρομή από τη μετάβαση

59
00:02:55,140 --> 00:02:58,149
να το μηδέν σε c.

60
00:02:58,149 --> 00:03:00,190
Το επόμενο είδος του βρόχου είναι
στην πραγματικότητα αρκετά παρόμοια.

61
00:03:00,190 --> 00:03:02,860
Έχει καλέσει το do while loop.

62
00:03:02,860 --> 00:03:07,060
Αυτός ο βρόχος θα εκτελέσει όλες τις γραμμές
του κώδικα μεταξύ των άγκιστρα φορά,

63
00:03:07,060 --> 00:03:09,530
και, στη συνέχεια, θα ελέγξει
η λογική έκφραση.

64
00:03:09,530 --> 00:03:11,700
Αν η λογική έκφραση
είναι αληθής,

65
00:03:11,700 --> 00:03:14,340
θα πάει πίσω και επαναλάβετε
ότι η διαδικασία ξανά και ξανά

66
00:03:14,340 --> 00:03:17,690
και ξανά μέχρι το Boolean
έκφραση είναι ψευδής.

67
00:03:17,690 --> 00:03:23,370
Έτσι, αυτό το βρόχο, σε αντίθεση με ένα βρόχο while, είναι
εγγυημένη για να τρέξει τουλάχιστον μία φορά.

68
00:03:23,370 --> 00:03:26,080
Αυτό μπορεί να είναι αρκετά χρήσιμο.

69
00:03:26,080 --> 00:03:28,011
>> Τέλος, έχουμε ένα για το βρόχο.

70
00:03:28,011 --> 00:03:30,010
Για βρόχοι είναι το είδος του
συντακτικά ελκυστική

71
00:03:30,010 --> 00:03:32,330
και υπάρχει μια παρτίδα σε εξέλιξη
εδώ, έτσι ώστε να φέρει μαζί μου

72
00:03:32,330 --> 00:03:34,640
καθώς προσπαθούμε και να σπάσει αυτά τα κομμάτια μεταξύ τους.

73
00:03:34,640 --> 00:03:36,810
Σε γενικές γραμμές, η περίπτωση χρήσης
ενός βρόχου for είναι εσείς

74
00:03:36,810 --> 00:03:40,136
θέλω να επαναλάβω κάτι
συγκεκριμένο αριθμό φορών.

75
00:03:40,136 --> 00:03:42,010
Σε αυτό το παράδειγμα εδώ,
Έχω την επανάληψη μπλοκ

76
00:03:42,010 --> 00:03:44,010
από την αρχή, η οποία είναι
ανάλογο με το βρόχο for

77
00:03:44,010 --> 00:03:47,340
σε C, επαναλαμβάνοντας κάτι 10 φορές.

78
00:03:47,340 --> 00:03:49,250
Και για το βρόχο για
η αριστερά εκεί, η οποία

79
00:03:49,250 --> 00:03:51,410
είναι τέσσερις βρόχο που
θα κάνουμε το ίδιο πράγμα.

80
00:03:51,410 --> 00:03:52,570
Αυτό θα πάει 10 φορές.

81
00:03:52,570 --> 00:03:56,720
Μετρώντας από το μηδέν, εμείς
αυξήσετε κάθε πέρασμα του βρόχου.

82
00:03:56,720 --> 00:03:59,220
Και συνεχίζουμε να το κάνουμε αυτό
μέχρι θ είναι μικρότερη από 10.

83
00:03:59,220 --> 00:04:00,134
>> Έτσι τι συμβαίνει;

84
00:04:00,134 --> 00:04:01,550
Υπάρχουν ένα σωρό κώδικα εκεί.

85
00:04:01,550 --> 00:04:03,424
Ας το σπάσει για να
τι συμβαίνει βήμα

86
00:04:03,424 --> 00:04:05,684
από το βήμα καθώς σκάβουν μέσα από ένα βρόχο for.

87
00:04:05,684 --> 00:04:08,350
Το πρώτο πράγμα που συνέβη είναι
ο μετρητής μεταβλητή είναι το κέντρο.

88
00:04:08,350 --> 00:04:11,970
Τα πάντα στα αριστερά της πρώτης
ερωτηματικό μέσα στις παρενθέσεις

89
00:04:11,970 --> 00:04:12,970
εκτελείται.

90
00:04:12,970 --> 00:04:15,180
Σε αυτή την περίπτωση, είμαστε
λέγοντας int i ισούται με 0.

91
00:04:15,180 --> 00:04:18,709
Δηλώνοντας μια νέα μεταβλητή που ονομάζεται i,
ότι οι μεταβλητές είναι ένα είδος ακέραιος

92
00:04:18,709 --> 00:04:22,570
και λέμε την αξία μέσα
ότι η μεταβλητή θα είναι μηδέν.

93
00:04:22,570 --> 00:04:25,480
>> Το δεύτερο πράγμα που κάνουμε είναι
μπορούμε στη συνέχεια να αξιολογήσουν αμέσως

94
00:04:25,480 --> 00:04:26,750
η λογική έκφραση.

95
00:04:26,750 --> 00:04:30,100
Boolean έκφραση είναι στην
μέση των δύο ερωτηματικά.

96
00:04:30,100 --> 00:04:31,360
Ι είναι μικρότερη από 10.

97
00:04:31,360 --> 00:04:32,410
Αυτό είναι αλήθεια εδώ, σωστά;

98
00:04:32,410 --> 00:04:36,030
Εμείς απλά είπα ότι είναι ίση με
μηδέν, και έτσι 0 είναι μικρότερη από 10,

99
00:04:36,030 --> 00:04:38,040
και έτσι ώστε η κατάσταση
Είναι αλήθεια και τώρα θα

100
00:04:38,040 --> 00:04:40,640
προχωρήσει να εκτελέσει το σώμα του βρόχου.

101
00:04:40,640 --> 00:04:41,480
Αν ήταν ψευδής.

102
00:04:41,480 --> 00:04:46,380
Αν, για παράδειγμα, είπα αντί
i ισούται με 0 εκεί είπα ότι ισούται με 15,

103
00:04:46,380 --> 00:04:47,820
int i ισούται με 15.

104
00:04:47,820 --> 00:04:51,450
Καλά 15 δεν είναι μικρότερη από 10, έτσι ώστε να
Ποτέ δεν θα εισέρχονται στο σώμα του βρόχου

105
00:04:51,450 --> 00:04:55,450
επειδή η λογική έκφραση
θα υπήρχε αξιολογήσει ότι είναι ψευδείς.

106
00:04:55,450 --> 00:04:59,060
>> Μετά περνάμε από πάνω προς τα κάτω,
συναντούμε ότι το κλείσιμο σγουρά στήριγμα,

107
00:04:59,060 --> 00:05:00,830
ένα τρίτο πράγμα που συμβαίνει.

108
00:05:00,830 --> 00:05:03,840
Ο μετρητής είναι μεταβλητή
αυξάνεται, ή μάλλον, οι γραμμές

109
00:05:03,840 --> 00:05:07,790
του κώδικα δηλώσεις του μετά το
δεύτερο ερωτηματικό στο εσωτερικό της

110
00:05:07,790 --> 00:05:10,500
για βρόχους παρενθέσεις εκτελείται.

111
00:05:10,500 --> 00:05:13,250
Ξεκινάμε λοιπόν από
λέγοντας int i ισούται με 0.

112
00:05:13,250 --> 00:05:15,770
Στη συνέχεια ελέγχουμε εάν ή όχι
η Boolean έκφραση είναι αληθής.

113
00:05:15,770 --> 00:05:17,469
0 είναι μικρότερη από 10 γι 'αυτό είναι αλήθεια.

114
00:05:17,469 --> 00:05:19,510
Έτσι θα πάμε να προχωρήσει
μέσα στο σώμα ο βρόχος.

115
00:05:19,510 --> 00:05:22,676
Τα πράγματα θα συμβούν μέσα στο βρόχο, και
όταν συναντούμε ότι το κλείσιμο σγουρά

116
00:05:22,676 --> 00:05:25,660
στήριγμα, το επόμενο πράγμα που
κάνουμε είναι να λέμε i συν, συν.

117
00:05:25,660 --> 00:05:28,860
Ήμουν μηδέν Τώρα είναι ένα.

118
00:05:28,860 --> 00:05:33,100
Στη συνέχεια, ελέγξτε και πάλι την αξία του
ο Boolean έκφραση στη μέση.

119
00:05:33,100 --> 00:05:34,900
Ένας είναι μικρότερη από 10.

120
00:05:34,900 --> 00:05:38,325
Έτσι θα πάμε μέσα από αυτό
επεξεργαστεί ξανά και ξανά.

121
00:05:38,325 --> 00:05:40,590
Θα φτάσουμε στο κλείσιμο
σγουρά στήριγμα και πάλι.

122
00:05:40,590 --> 00:05:44,090
Θα αυξήσετε i από
1 έως 2 και από 2 ως 3.

123
00:05:44,090 --> 00:05:48,290
Και ούτω καθεξής και ούτω καθεξής και ούτω καθεξής, μέχρις ότου
τελικά αξία i γίνεται 10.

124
00:05:48,290 --> 00:05:49,950
Είναι μικρότερη από 10 10;

125
00:05:49,950 --> 00:05:51,200
Κανένα.

126
00:05:51,200 --> 00:05:53,800
Μετρώντας από 0, έχουμε πάει
με 10 επαναλήψεις βρόχου.

127
00:05:53,800 --> 00:05:57,204
Έχουμε επαναλαμβάνεται 10 φορές, απλά
όπως κάναμε στο μπλοκ Ξυστό.

128
00:05:57,204 --> 00:05:59,370
Και έτσι αυτό είναι βασικά η
διαδικασία για μια περίοδο τεσσάρων βρόχο.

129
00:05:59,370 --> 00:06:01,630
>> Τώρα αφαιρώντας το
πραγματικό κώδικα και τη θέση της

130
00:06:01,630 --> 00:06:05,120
σε μόλις μερικές βασικές γενικές δηλώσεις.

131
00:06:05,120 --> 00:06:06,550
Εδώ είναι τι θα συμβεί.

132
00:06:06,550 --> 00:06:09,290
Όλες οι δηλώσεις
ξεκινήστε εκτελούνται πρώτα.

133
00:06:09,290 --> 00:06:11,260
Μπορείτε να έχετε περισσότερες από μία.

134
00:06:11,260 --> 00:06:13,440
Στη συνέχεια, η Boolean έκφραση ελέγχεται.

135
00:06:13,440 --> 00:06:17,850
Αν η έκφραση είναι αληθής,
εκτελέσει το σώμα του βρόχου ένα χρόνο.

136
00:06:17,850 --> 00:06:21,060
Αν η έκφραση αξιολογεί
ψευδείς, τελειώσαμε.

137
00:06:21,060 --> 00:06:23,040
Εμείς δεν εκτελούν το
σώμα του βρόχου καθόλου.

138
00:06:23,040 --> 00:06:25,530
Μετά έχουμε την εκτέλεση της
σώμα ο βρόχος μία φορά,

139
00:06:25,530 --> 00:06:29,487
Στη συνέχεια, κάνουμε ό, τι είναι
το μέρος προσαύξηση εκεί.

140
00:06:29,487 --> 00:06:31,820
Η οποία είναι συνήθως πρόκειται να είναι
κάτι σαν i συν, συν

141
00:06:31,820 --> 00:06:34,510
ή κάτι τέτοιο, ότι
τροποποιεί ένα μετρητή μεταβλητή.

142
00:06:34,510 --> 00:06:37,390
Στη συνέχεια, αφού αυξήσετε, εμείς
ελέγξτε και πάλι την έκφραση

143
00:06:37,390 --> 00:06:41,120
και επαναλάβετε αυτά τα βήματα ξανά και ξανά
και ξανά μέχρι η έκφραση είναι

144
00:06:41,120 --> 00:06:42,890
δεν ισχύει πλέον.

145
00:06:42,890 --> 00:06:44,469
>> Έτσι, ποιες είναι οι περιπτώσεις χρήσης για ένα βρόχο;

146
00:06:44,469 --> 00:06:46,760
Χρησιμοποιήστε χρησιμοποιείτε ένα βρόχο, ενώ όταν
θέλετε ένα βρόχο να επαναλάβω

147
00:06:46,760 --> 00:06:51,200
ένας άγνωστος αριθμός των φορές, αλλά
αυτό ενδεχομένως να μην λειτουργούν καθόλου.

148
00:06:51,200 --> 00:06:53,940
Μια πραγματικά κοινό παράδειγμα
ενώ ένα looping χρησιμοποιείται

149
00:06:53,940 --> 00:06:56,480
είναι να τρέξει τη ροή ελέγχου για ένα παιχνίδι.

150
00:06:56,480 --> 00:06:59,040
Μπορεί να μην ξέρω πόσο καιρό η
χρήστης πρόκειται να παίζει,

151
00:06:59,040 --> 00:07:01,440
αλλά θέλετε να κρατήσετε
κάνει το ίδιο πράγμα.

152
00:07:01,440 --> 00:07:04,970
Ενημέρωση των θέσεων
διάφορα ξωτικά στο διοικητικό συμβούλιο.

153
00:07:04,970 --> 00:07:07,490
Θέλετε να κρατήσετε τα πράγματα
κινείται σε κάθε στιγμή,

154
00:07:07,490 --> 00:07:09,110
αλλά δεν ξέρετε πότε το
χρήστης πρόκειται να σταματήσει να παίζει

155
00:07:09,110 --> 00:07:10,450
ή όταν πρόκειται
να τελειώσουν οι ζωές.

156
00:07:10,450 --> 00:07:12,741
Έτσι, ένας βρόχος while είναι πραγματικά
καλό για κάτι τέτοιο.

157
00:07:12,741 --> 00:07:14,130
Αυτή είναι μια καλή περίπτωση χρήσης.

158
00:07:14,130 --> 00:07:16,230
>> Για do while loop,
είναι αρκετά παρόμοια.

159
00:07:16,230 --> 00:07:19,746
Θέλετε ένα βρόχο να επαναλάβω μια άγνωστη
πολλές φορές, αλλά τουλάχιστον μία φορά.

160
00:07:19,746 --> 00:07:22,370
Μπορείτε να χρησιμοποιήσετε αυτό για ένα παιχνίδι
πάρα πολύ, αλλά μια πραγματικά κοινή υπόθεση χρήσης

161
00:07:22,370 --> 00:07:24,420
ωθεί το χρήστη για την είσοδο.

162
00:07:24,420 --> 00:07:28,609
Σε γενικές γραμμές, θα μπορούσε να πει κάτι
όπως, να μου δώσει ένα θετικό ακέραιο,

163
00:07:28,609 --> 00:07:30,650
και μπορείτε να βάλετε ότι
μέσα σε ένα do while loop.

164
00:07:30,650 --> 00:07:33,900
Γι 'αυτό θα τους ζητήσει πάντα
τουλάχιστον μία φορά για ένα θετικό ακέραιο.

165
00:07:33,900 --> 00:07:36,850
Αν σας δώσω ένα θετικό ακέραιο,
μπορεί να ξεφύγει από το βρόχο.

166
00:07:36,850 --> 00:07:37,599
Μπορεί να γίνει.

167
00:07:37,599 --> 00:07:39,900
Η Boolean έκφραση σε
αυτό το διάστημα κάνει μπορεί να είναι ψευδής.

168
00:07:39,900 --> 00:07:41,137
>> Και δεν θα τους ζητήσει και πάλι.

169
00:07:41,137 --> 00:07:44,470
Αν σας δώσω ένα αρνητικό αριθμό, όπου
πληκτρολογεί κάποια λέξη ή κάτι που είναι

170
00:07:44,470 --> 00:07:46,630
δεν είναι πραγματικά χρήσιμο να
σας, μπορείτε να χρησιμοποιήσετε το

171
00:07:46,630 --> 00:07:49,770
δεν βρόχος while να πάτε πίσω και να κάνουμε
ξανά και ξανά και ξανά.

172
00:07:49,770 --> 00:07:52,410
Σίγουρα θέλω να ρωτήσω
να σας δώσω έναν αριθμό φορά,

173
00:07:52,410 --> 00:07:56,350
αλλά δεν ξέρετε πόσες φορές
μετά από αυτό θα μπορούσαν να είναι τα παράσιτα.

174
00:07:56,350 --> 00:08:00,540
Και έτσι ένα do ενώ είναι μια μεγάλη χρήση
θήκη για προτρέπει το χρήστη για την είσοδο.

175
00:08:00,540 --> 00:08:03,060
Και για χρήση βρόχων
περίπτωση είναι συνήθως όταν

176
00:08:03,060 --> 00:08:06,230
θέλετε να επαναλάβετε ένα βρόχο
ένα διακριτό αριθμό φορών,

177
00:08:06,230 --> 00:08:08,230
και αν δεν μπορείτε
γνωρίζουν τον αριθμό των φορών

178
00:08:08,230 --> 00:08:10,040
τη στιγμή που το πρόγραμμα μεταγλωττιστεί.

179
00:08:10,040 --> 00:08:15,510
>> Έτσι, για παράδειγμα, ίσως έχετε ένα πρόγραμμα
όπου μπορείτε να ζητήσει από το χρήστη για έναν αριθμό.

180
00:08:15,510 --> 00:08:17,660
Και μπαίνουν 100.

181
00:08:17,660 --> 00:08:20,510
Και τότε σας για βρόχο θα
σε αυτή την περίπτωση να τρέξει 100 φορές.

182
00:08:20,510 --> 00:08:22,480
Ή ίσως εισέλθουν
1.000 στο πρόγραμμά σας

183
00:08:22,480 --> 00:08:24,570
και στη συνέχεια εκτελέστε το βρόχο 1.000 φορές.

184
00:08:24,570 --> 00:08:26,987
Είναι ένα συγκεκριμένο αριθμό φορών.

185
00:08:26,987 --> 00:08:28,820
Δεν είναι απαραίτητα
ξέρετε τι αυτό τον αριθμό

186
00:08:28,820 --> 00:08:31,010
είναι το πρόγραμμα στιγμή έχει συνταχθεί.

187
00:08:31,010 --> 00:08:35,010
Δεν είναι σαν ένα while loop
όπου θα μπορούσε να είναι άπειρη.

188
00:08:35,010 --> 00:08:37,127
Είναι μάλλον μια σειρά
ότι απλά δεν ξέρω.

189
00:08:37,127 --> 00:08:39,210
Τώρα, ακόμη και αν έχω
περιγράφονται όλες αυτές οι περιπτώσεις χρήσης,

190
00:08:39,210 --> 00:08:41,501
θα πρέπει να γνωρίζετε ότι σε αρκετά
πολύ κάθε περίσταση,

191
00:08:41,501 --> 00:08:44,110
μπορείτε να εναλλάσσετε όλα
τρεις από αυτές τις θηλιές.

192
00:08:44,110 --> 00:08:46,890
Μπορείτε να χρησιμοποιήσετε ένα βρόχο for, όπου μπορείτε
θα έπρεπε να χρησιμοποιήσει ένα βρόχο while.

193
00:08:46,890 --> 00:08:49,860
Μπορείτε να χρησιμοποιήσετε ένα βρόχο for όπου
θέλετε να χρησιμοποιήσετε ένα do while loop και ούτω καθεξής.

194
00:08:49,860 --> 00:08:53,680
Μπορεί να είναι λίγο δύσκολο μερικές φορές,
έτσι γενικά είναι μια καλή πρακτική

195
00:08:53,680 --> 00:08:55,140
να εμμείνει σε μια τυπική περίπτωση χρήσης.

196
00:08:55,140 --> 00:08:57,599
Χρησιμοποιήστε ένα do while loop αν
ήθελε κάτι μία φορά, τουλάχιστον.

197
00:08:57,599 --> 00:09:00,514
Χρησιμοποιήστε ένα για το βρόχο, αν θέλετε να κάνετε
κάτι συγκεκριμένο αριθμό φορών.

198
00:09:00,514 --> 00:09:03,730
Μετά από όλα, γι 'αυτό υπάρχουν
τρία διαφορετικά είδη βρόχων.

199
00:09:03,730 --> 00:09:06,172
>> Έτσι μπορούν να χρησιμοποιηθούν
στο σωστό πλαίσιο.

200
00:09:06,172 --> 00:09:07,880
Αλλά μπορείτε να εναλλάσσετε
τους αν θέλετε.

201
00:09:07,880 --> 00:09:10,790
Εάν αισθάνεστε άνετα με while loops
και θέλετε πάντα να χρησιμοποιήσετε, ενώ βρόχους.

202
00:09:10,790 --> 00:09:12,623
Είναι κάτι που
μπορείτε να το κάνετε, αν και

203
00:09:12,623 --> 00:09:15,590
Μπορεί να είναι λίγο συντακτικά
δύσκολο, όταν ένα βρόχο for

204
00:09:15,590 --> 00:09:17,850
θα είναι πολύ πιο απλή.

205
00:09:17,850 --> 00:09:21,100
>> Το όνομά μου είναι Doug Lloyd και αυτό είναι CS50.

206
00:09:21,100 --> 00:09:22,688