1
00:00:00,000 --> 00:00:00,493

2
00:00:00,493 --> 00:00:09,860
>> [За възпроизвеждане на музика]

3
00:00:09,860 --> 00:00:13,520
>> ZAMYLA CHAN: Бихте ли скоро получават
$ 10,00 милиона сега или получавате

4
00:00:13,520 --> 00:00:17,460
пари всеки ден от месеца, когато е
всеки следващ ден, получавате

5
00:00:17,460 --> 00:00:21,280
двоен размер на пари ви
получили в деня преди?

6
00:00:21,280 --> 00:00:24,010
В пари, ние ще
докаже защо трябва да

7
00:00:24,010 --> 00:00:27,000
Определено вземат пари.

8
00:00:27,000 --> 00:00:29,130
Вашата работа е да се напише pennies.c--

9
00:00:29,130 --> 00:00:33,330
програма, която първо пита потребителя как
много дни има в месеца и

10
00:00:33,330 --> 00:00:38,780
след това пита колко пари на потребителя
ще получат на първия ден.

11
00:00:38,780 --> 00:00:41,780
Програмата след това трябва да се изчисли
сумата, която потребителят ще трябва

12
00:00:41,780 --> 00:00:46,530
натрупана в края на
месеца и ще го покаже.

13
00:00:46,530 --> 00:00:49,670
>> Ние може да разбие тази програма до
в няколко задачи.

14
00:00:49,670 --> 00:00:52,830
Ние ще трябва да се пита за
множество данни от потребителя -

15
00:00:52,830 --> 00:00:55,510
дни и месеци, и стотинките
на първия ден.

16
00:00:55,510 --> 00:00:59,390
Трябва да следите колко пари
потребителят трябва и да го актуализира всеки

17
00:00:59,390 --> 00:01:03,060
ден, удвояване на размера на
пари, които получават.

18
00:01:03,060 --> 00:01:06,710
И накрая, ние принтират
крайна общо в долари.

19
00:01:06,710 --> 00:01:08,570
>> Нека приноса на потребителите шпагат първи.

20
00:01:08,570 --> 00:01:11,560
Отивам да се отворят apples.c,
кратка програма, която се занимава

21
00:01:11,560 --> 00:01:13,840
с входове и изходи.

22
00:01:13,840 --> 00:01:17,310
На върха тук, сме включили някои
на библиотеките, които трябва -

23
00:01:17,310 --> 00:01:20,450
CS50 библиотека и стандартен
I / O библиотека.

24
00:01:20,450 --> 00:01:24,310
I отпечатате бързо с помощта на
ФОРМАТ функция от

25
00:01:24,310 --> 00:01:25,660
стандартна I / O библиотека.

26
00:01:25,660 --> 00:01:29,740
Но действителната подтика на потребителя
се случва в следващия ред с този

27
00:01:29,740 --> 00:01:33,650
GetInt функция в библиотеката CS50.

28
00:01:33,650 --> 00:01:38,300
>> GetInt получава информация от потребителя и
гарантира, че на входа е цяло число.

29
00:01:38,300 --> 00:01:45,160
Така че аз се съхранява въвеждане на потребителя в цяло число
Аз, се изважда една от I, и след това

30
00:01:45,160 --> 00:01:47,610
отпечатване на нова стойност, ако аз.

31
00:01:47,610 --> 00:01:53,050
След събиране apples.c използва
команда "направи ябълки," Имам

32
00:01:53,050 --> 00:01:55,770
ябълки изпълним файл.

33
00:01:55,770 --> 00:01:58,760
Спринт че, аз ще вход 1.

34
00:01:58,760 --> 00:02:02,600
Програмата ми казва, че
Имам 0 останали ябълки.

35
00:02:02,600 --> 00:02:05,480
И така, който работи както се очаква.

36
00:02:05,480 --> 00:02:09,740
>> Така че нека да тичам отново
и въвеждане на отрицателен 1.

37
00:02:09,740 --> 00:02:13,950
Сега, като отрицателна сума на ябълки
не наистина да има смисъл, но

38
00:02:13,950 --> 00:02:18,370
програмата го приема, защото отрицателно
1, и е цяло число.

39
00:02:18,370 --> 00:02:22,740
И сега на програмата или на чудовището
в рамките на програмата яде отрицателно

40
00:02:22,740 --> 00:02:26,250
ябълка, и сега имам
отрицателни две ябълки.

41
00:02:26,250 --> 00:02:28,610
Хм, така че това е един урок -

42
00:02:28,610 --> 00:02:32,965
въпреки че GetInt функция и
функции, свързани с подобни GetFlow или

43
00:02:32,965 --> 00:02:38,100
GetString получите правилния тип данни,
трябва да се уверите, че на входа прави

44
00:02:38,100 --> 00:02:41,430
чувство за вашата програма.

45
00:02:41,430 --> 00:02:45,500
>> В пари, той няма да направи точно бърз
за цяло число, ще трябва да се направи

46
00:02:45,500 --> 00:02:49,550
уверите, че потребителските въвеждания цяло число
че има смисъл като се има предвид контекста.

47
00:02:49,550 --> 00:02:55,690
Месец може да има само 28,
29, 30 или 31 дни.

48
00:02:55,690 --> 00:02:59,160
Искаме да изисква непрекъснато
валиден число.

49
00:02:59,160 --> 00:03:03,240
Ако входа цяло число извън нашата
приетите граници, ще ги подтикне

50
00:03:03,240 --> 00:03:07,190
отново и отново, докато не
да ни даде валиден число.

51
00:03:07,190 --> 00:03:10,070
>> Спомнете си "многократно, докато"
блок в Scratch?

52
00:03:10,070 --> 00:03:13,070
Можете да направите подобен конструкт
в С с използване на "а" линия

53
00:03:13,070 --> 00:03:14,830
или "направи, докато" линия.

54
00:03:14,830 --> 00:03:18,280
Структурата линия, докато има състояние
, които трябва да бъдат изпълнени за

55
00:03:18,280 --> 00:03:20,160
тялото на цикъла да се изпълни.

56
00:03:20,160 --> 00:03:23,080
>> Това би трябвало да изглежда малко по-сходни,
защото състоянието е подобно на

57
00:03:23,080 --> 00:03:25,970
Scratch блокове с ъглите
и отива в скоби

58
00:03:25,970 --> 00:03:27,950
на "а" примка.

59
00:03:27,950 --> 00:03:30,600
Така че това условие ще провери дали
числото е в рамките

60
00:03:30,600 --> 00:03:32,680
съответните граници.

61
00:03:32,680 --> 00:03:36,620
Можете да подтикне число използване GetInt
и след това да си "а"

62
00:03:36,620 --> 00:03:41,030
линия, повтаряща се на бързото и печат
инструкции, докато на входа

63
00:03:41,030 --> 00:03:43,470
не е валиден.

64
00:03:43,470 --> 00:03:47,610
>> Друг начин да се гарантира правилното въвеждане от потребителя
е с помощта на "направи-а" примка,

65
00:03:47,610 --> 00:03:50,400
който е много подобен на линия, докато.

66
00:03:50,400 --> 00:03:54,950
The "направи, докато" примка изпълнява код
вътре в тялото и след това тези проверки

67
00:03:54,950 --> 00:03:57,150
дали условието е изпълнено или не.

68
00:03:57,150 --> 00:04:00,590
Това е полезно за получаване на приноса на потребителите,
защото вие знаете, че имате нужда

69
00:04:00,590 --> 00:04:02,980
да ги подтикне най-малко веднъж.

70
00:04:02,980 --> 00:04:07,200
Ако условието не е изпълнено, програмата
ще изпълни линия след

71
00:04:07,200 --> 00:04:08,530
ви "направи, докато" линия.

72
00:04:08,530 --> 00:04:13,230
Ако условието е изпълнено, обаче,
на цикъл ще се повтаря

73
00:04:13,230 --> 00:04:17,490
>> A "направи, докато" линия за валидиране на потребителя
вход ще изглежда по следния начин.

74
00:04:17,490 --> 00:04:24,530
Декларирам, променлива N, GetInt, и
след това се повтаря, докато п е валиден.

75
00:04:24,530 --> 00:04:28,040
И този процес, обясних, е използвал
цялото число-тип данни, които

76
00:04:28,040 --> 00:04:29,820
ще използвате за дните на месеца.

77
00:04:29,820 --> 00:04:33,560
Но ние знаем, че броят на пари
ще се трупат бързо, така че, за да се

78
00:04:33,560 --> 00:04:39,160
запомнят по-големи числа, използвайте тип данни
LongLong, но не забравяйте, същото

79
00:04:39,160 --> 00:04:42,590
принципа на валидиране се прилага.

80
00:04:42,590 --> 00:04:47,070
>> Awesome, така че щом имаме две валидни
суровини от страна на потребителя -

81
00:04:47,070 --> 00:04:49,530
дни в месеца и стотинките
на първия ден -

82
00:04:49,530 --> 00:04:52,870
ние може да преминете към следващата
част от програмата.

83
00:04:52,870 --> 00:04:56,680
Първият ден, потребителят започва с
обаче много пари те посочени

84
00:04:56,680 --> 00:05:00,370
и сумата от пари, че те
получават на следващия ден се удвоява.

85
00:05:00,370 --> 00:05:03,130
Така че има смисъл, за да следите
от тези две суми -

86
00:05:03,130 --> 00:05:08,890
колко пари потребителят трябва и как
много пари, че ще се обърне.

87
00:05:08,890 --> 00:05:13,760
>> Сега, прави нещо в продължение на 28 до 31 дни
е повтаряща се, така че нека да се използва "за"

88
00:05:13,760 --> 00:05:18,220
линия, за да превъртате през ден в
месеца, актуализиране на общия и стотинка

89
00:05:18,220 --> 00:05:21,010
възлиза всеки път.

90
00:05:21,010 --> 00:05:23,550
"За" примка синтаксис съдържа
следното -

91
00:05:23,550 --> 00:05:27,510
инициализация, условие,
и актуализация.

92
00:05:27,510 --> 00:05:29,590
Вие "за" линия ще се инициализира
променлива, когато

93
00:05:29,590 --> 00:05:31,380
първо започва цикъла.

94
00:05:31,380 --> 00:05:34,860
Ако условието е изпълнено, тялото
на цикъла ще се изпълни.

95
00:05:34,860 --> 00:05:36,860
След това, актуализацията ще се изпълни.

96
00:05:36,860 --> 00:05:40,900
Ако състоянието е все още изпълнени,
линия ще изпълни и актуализира, и

97
00:05:40,900 --> 00:05:45,820
Повтарям, толкова дълго, колкото Ви състояние
Проверява.

98
00:05:45,820 --> 00:05:51,080
>> Ето един "за" линия, която разделя на
цяло число от 2 стр. общо 10 пъти.

99
00:05:51,080 --> 00:05:55,380
Забележете как се обявява число стр.
извън моя "за" линия, така че

100
00:05:55,380 --> 00:05:59,850
число може да бъде достъпна
извън "за" линия.

101
00:05:59,850 --> 00:06:03,620
След месец е преминал, е време
да съобщите на потребителя, колко пари

102
00:06:03,620 --> 00:06:04,790
те сте придобили.

103
00:06:04,790 --> 00:06:08,740
Per спецификацията, трябва да съобщите на потребителя
колко долара, а не колко

104
00:06:08,740 --> 00:06:10,780
пари, които имат.

105
00:06:10,780 --> 00:06:14,620
Но до този момент, вие сте следили на
общо и пари използващи LongLongs,

106
00:06:14,620 --> 00:06:16,640
които са цели числа.

107
00:06:16,640 --> 00:06:20,560
>> Има 100 пари до $ 1, така че освен ако
броят на пари е

108
00:06:20,560 --> 00:06:24,860
кратно на 100, ще трябва да
представляват знака след десетичната запетая.

109
00:06:24,860 --> 00:06:28,060
The удвои автотипия позволява
можете да направите това.

110
00:06:28,060 --> 00:06:32,790
И как ще се превърне в гол от представляващи
пари на долара?

111
00:06:32,790 --> 00:06:35,330
>> Нека да разгледаме pi.c.

112
00:06:35,330 --> 00:06:41,690
Тази програма отнема LongLong big_pi и
разделя го на 100 000, и отпечатва

113
00:06:41,690 --> 00:06:44,270
резултат до пет знака след десетичната запетая.

114
00:06:44,270 --> 00:06:48,560
Ако искахме да се покаже четири знака след десетичната
места, тогава може просто да замени настоящия

115
00:06:48,560 --> 00:06:49,760
номер тук.

116
00:06:49,760 --> 00:06:58,370
Така че нека да спести, съставяне пи, и
После ще видиш резултат, който ние

117
00:06:58,370 --> 00:07:02,240
Очакваме да бъдете 3.1415 -

118
00:07:02,240 --> 00:07:04,540
първите пет цифри от PI.

119
00:07:04,540 --> 00:07:06,300
>> Не е все пак.

120
00:07:06,300 --> 00:07:07,390
И защо?

121
00:07:07,390 --> 00:07:11,920
Ами, защото big_pi е LongLong,
която е цяло число, което няма да

122
00:07:11,920 --> 00:07:13,740
да следите знака след десетичната запетая.

123
00:07:13,740 --> 00:07:16,850
Промяната трябва да
да е в разделянето.

124
00:07:16,850 --> 00:07:23,300
Трябва да се хвърли към двоен тук преди
разделяне, тъй двойки не могат да

125
00:07:23,300 --> 00:07:25,260
следите на знака след десетичната запетая.

126
00:07:25,260 --> 00:07:28,080
И аз отивам да добавите нов ред
тук за по-добро форматиране.

127
00:07:28,080 --> 00:07:33,090

128
00:07:33,090 --> 00:07:34,230
>> И тук ние я имаме -

129
00:07:34,230 --> 00:07:37,660
3.1416.

130
00:07:37,660 --> 00:07:43,520
Може да забележите, че той печата 3.1416
вместо 3,1415, както се очаква.

131
00:07:43,520 --> 00:07:47,550
Това е, защото по време на кръга
делене, а не само

132
00:07:47,550 --> 00:07:50,490
отрязване на стойността.

133
00:07:50,490 --> 00:07:53,710
Сега би трябвало да можете да отпечатате
крайната обща правилно, което завършва

134
00:07:53,710 --> 00:07:54,870
програмата.

135
00:07:54,870 --> 00:07:55,930
>> Поздравления.

136
00:07:55,930 --> 00:07:57,340
Моето име е Zamyla.

137
00:07:57,340 --> 00:07:58,720
И това е пари.

138
00:07:58,720 --> 00:08:05,589
>> [За възпроизвеждане на музика]