1
00:00:00,000 --> 00:00:00,440

2
00:00:00,440 --> 00:00:03,440
>> SPEAKER 1: Ultima dată când am analizat
numere întregi, amintesc că am folosit unele

3
00:00:03,440 --> 00:00:07,810
Expresii booleene pentru a verifica dacă un utilizator
intrare n fost între numere

4
00:00:07,810 --> 00:00:11,580
cum ar fi 0 și 3, 4 și 7, și 8 și 10.

5
00:00:11,580 --> 00:00:14,990
Ei bine, am făcut-o, folosind dacă e și altceva
în cazul lui, dar se pare că se poate

6
00:00:14,990 --> 00:00:17,990
să pună în aplicare aceeași logică, folosind un
alt construct de programare

7
00:00:17,990 --> 00:00:21,400
totul în timp ce încă realizarea
exact același rezultat.

8
00:00:21,400 --> 00:00:25,000
De fapt, putem introduce ceva
numit un comutator care ne permite să

9
00:00:25,000 --> 00:00:28,660
schimba comportamentul nostru, în funcție de
valoarea unor variabile.

10
00:00:28,660 --> 00:00:29,840
>> Să-i dăm această un try.

11
00:00:29,840 --> 00:00:35,730
Pentru a face acest lucru, eu sunt în primul rând de gând să includă
biblioteca CS50 prin cs50.h.

12
00:00:35,730 --> 00:00:39,960
Am de asemenea, va include standardul
bibliotecă prin standard de I / O.h.

13
00:00:39,960 --> 00:00:44,540
Și am de gând să declare principal în
ca de obicei, int main.

14
00:00:44,540 --> 00:00:45,650
Deschide acoladă.

15
00:00:45,650 --> 00:00:47,100
Închideți acoladă.

16
00:00:47,100 --> 00:00:49,720
Și acum am de gând să solicite
de utilizator pentru un întreg.

17
00:00:49,720 --> 00:00:56,990
>> Printf, da-mi un int
între 1 și 10.

18
00:00:56,990 --> 00:00:59,310
Și acum am de gând pentru a obține
care int folosind CS50

19
00:00:59,310 --> 00:01:01,590
biblioteci funcționează, getint.

20
00:01:01,590 --> 00:01:06,140
Int, hai să o numim n, este egal cu getint.

21
00:01:06,140 --> 00:01:08,500
Și acum am de gând să fac un pic
de analiză pe care întreg.

22
00:01:08,500 --> 00:01:13,120
Oarecum arbitrar, dar cu această
Noul construct cunoscut ca un comutator.

23
00:01:13,120 --> 00:01:16,530
Porniți valoarea lui n după cum urmează.

24
00:01:16,530 --> 00:01:23,240
>> In cazul in care n este egal cu 1, sau în
cazul in care n este egal cu 2, sau, în cazul

25
00:01:23,240 --> 00:01:28,150
că n este egal cu 3, mergeți mai departe și
executa această linie de cod.

26
00:01:28,150 --> 00:01:34,480
Printf ai ales un int mic, pauză.

27
00:01:34,480 --> 00:01:37,610
Acum, am nevoie pentru a pune în aplicare echivalentul
a unui ELT simplu de

28
00:01:37,610 --> 00:01:40,990
enumerând unele cazuri suplimentare.

29
00:01:40,990 --> 00:01:47,180
>> In cazul in care n este egal cu 4, sau în
cazul in care n este egal cu 5, sau în cazul

30
00:01:47,180 --> 00:01:53,830
care n este egal cu 6, sau în cazul în care n
este egal cu 7, mergeți mai departe și imprima te

31
00:01:53,830 --> 00:01:58,000
ales un Int mediu.

32
00:01:58,000 --> 00:01:59,490
Break.

33
00:01:59,490 --> 00:02:02,300
Acum, în cazul în care utilizatorul a ales
un număr mare, să

34
00:02:02,300 --> 00:02:04,940
detecta că, după cum urmează.

35
00:02:04,940 --> 00:02:08,900
>> În cazul în care utilizatorul a ales opt
sau în cazul în care utilizatorul alege

36
00:02:08,900 --> 00:02:14,110
noua, sau în cazul în care utilizatorul alege
10, mergeți mai departe și imprima te

37
00:02:14,110 --> 00:02:17,830
a luat o mare Int.

38
00:02:17,830 --> 00:02:19,180
Break.

39
00:02:19,180 --> 00:02:23,970
ELT, dacă un utilizator nu a alege un număr
care se încadrează în oricare dintre aceste 10 de cazuri,

40
00:02:23,970 --> 00:02:25,520
haideți să avem un comportament implicit.

41
00:02:25,520 --> 00:02:27,870
Care, în acest caz, va fi după cum urmează.

42
00:02:27,870 --> 00:02:32,860
>> Implicit, printf, ai ales
un Int invalid.

43
00:02:32,860 --> 00:02:36,100

44
00:02:36,100 --> 00:02:38,220
Break.

45
00:02:38,220 --> 00:02:42,870
Acum, dacă am salva acest compilare fișier
se face cu comutator.

46
00:02:42,870 --> 00:02:44,870
Rulați-l cu comutator slash..

47
00:02:44,870 --> 00:02:46,770
Să facem o pereche de controale bun-simț.

48
00:02:46,770 --> 00:02:48,440
Voi alege un Int de 1.

49
00:02:48,440 --> 00:02:50,110
Și ID-ul ales un int mic.

50
00:02:50,110 --> 00:02:52,240
>> Să facem acum. Slash comutator.

51
00:02:52,240 --> 00:02:54,514
Și tastați în zicem, negativ 1.

52
00:02:54,514 --> 00:02:56,900
Și ID-ul ales un int invalid.

53
00:02:56,900 --> 00:02:59,560
La sfârșitul zilei, comutatorul
construi nu vă permite să facă

54
00:02:59,560 --> 00:03:03,320
ceva ce nu a putut face deja
cu mult mai familiar în cazul în care, altfel, dacă,

55
00:03:03,320 --> 00:03:04,530
mai construi.

56
00:03:04,530 --> 00:03:07,470
Dar, dacă aveți o listă finită de valori
că sunteți de verificare pentru, un

57
00:03:07,470 --> 00:03:09,820
switch poate foarte
bine face codul de mai mult

58
00:03:09,820 --> 00:03:11,310
explicit, sau mai ușor de citit.

59
00:03:11,310 --> 00:03:12,910