1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
DOUG LLOYD: Tudo bem.

3
00:00:05,580 --> 00:00:08,877
Então agora vamos enfrentar uma
tópico realmente grande, as funções.

4
00:00:08,877 --> 00:00:11,460
Até agora, no curso, todo o
programas que tenho escrito

5
00:00:11,460 --> 00:00:12,969
ter sido escrito dentro do principal.

6
00:00:12,969 --> 00:00:14,260
Eles são programas muito simples.

7
00:00:14,260 --> 00:00:16,940
Você não precisa ter todos estes
ramos e coisas acontecendo.

8
00:00:16,940 --> 00:00:18,773
Podemos apenas caber tudo
dentro de principal e

9
00:00:18,773 --> 00:00:20,407
não ficar terrivelmente esmagadora.

10
00:00:20,407 --> 00:00:22,990
Mas, como o curso vai sobre e
quando você começa a desenvolver programas

11
00:00:22,990 --> 00:00:26,260
de forma independente, eles provavelmente vão
a começar a ficar muito mais do que 10

12
00:00:26,260 --> 00:00:27,200
ou 15 linhas.

13
00:00:27,200 --> 00:00:31,400
Você pode ter centenas ou milhares
ou dezenas de milhares de linhas de código.

14
00:00:31,400 --> 00:00:34,690
E isso realmente não é
que um pensamento louco.

15
00:00:34,690 --> 00:00:39,720
Como tal, ele provavelmente não é uma boa idéia
para manter tudo dentro do principal.

16
00:00:39,720 --> 00:00:43,240
Pode ficar um pouco difícil de encontrar
o que você está procurando se você fizer isso.

17
00:00:43,240 --> 00:00:47,040
>> Felizmente, porém C, e praticamente
cada outra linguagem de programação que

18
00:00:47,040 --> 00:00:50,386
pode trabalhar, permite
nós escrever funções.

19
00:00:50,386 --> 00:00:52,260
E eu estou indo só para
tomar um rápido aparte aqui

20
00:00:52,260 --> 00:00:54,971
de mencionar que é funções
uma área da ciência da computação.

21
00:00:54,971 --> 00:00:57,970
E você vai ver muitos mais deles em
vários pontos ao longo do curso

22
00:00:57,970 --> 00:00:59,290
e se você continuar.

23
00:00:59,290 --> 00:01:02,280
Onde há um monte de
sinónimos para a mesma palavra.

24
00:01:02,280 --> 00:01:03,390
Então, nós chamamos as funções.

25
00:01:03,390 --> 00:01:05,980
Mas você também pode ouvi-los
referido como procedimentos,

26
00:01:05,980 --> 00:01:09,570
ou métodos, em particular, se você já
feito qualquer programação orientada a objeto

27
00:01:09,570 --> 00:01:11,950
antes-- e não se preocupe
se você não tiver, não

28
00:01:11,950 --> 00:01:14,280
uma grande mas em deal--
linguagens orientadas auditoria

29
00:01:14,280 --> 00:01:16,129
são freqüentemente chamados métodos.

30
00:01:16,129 --> 00:01:17,670
Às vezes, eles são chamados de sub-rotinas.

31
00:01:17,670 --> 00:01:20,690
Mas eles realmente se referem
para a mesma ideia de base.

32
00:01:20,690 --> 00:01:22,480
>> Vamos ver o que é idéia.

33
00:01:22,480 --> 00:01:23,310
O que é uma função?

34
00:01:23,310 --> 00:01:26,470
Bem é realmente uma função
nada mais do que uma caixa preta.

35
00:01:26,470 --> 00:01:31,430
A caixa preta que tem um conjunto de zero,
ou mais entradas e um única saída.

36
00:01:31,430 --> 00:01:33,420
Assim, por exemplo, esta
pode ser uma função.

37
00:01:33,420 --> 00:01:35,510
Esta é uma função chamada func.

38
00:01:35,510 --> 00:01:39,330
E leva três entradas a, b e c.

39
00:01:39,330 --> 00:01:42,580
E dentro dessa caixa preta, que
Não sei exatamente o que ele faz,

40
00:01:42,580 --> 00:01:45,100
mas ele processa as entradas
de alguma forma e então

41
00:01:45,100 --> 00:01:48,680
dá uma única saída, neste caso, Z.

42
00:01:48,680 --> 00:01:50,504
Agora, para torná-lo um pouco
menos abstrata, nós

43
00:01:50,504 --> 00:01:52,420
poderia dizer que talvez nós
têm uma função chamada

44
00:01:52,420 --> 00:01:58,750
acrescentar que leva três entradas a, b, e
C e processa a saída de alguma maneira

45
00:01:58,750 --> 00:02:01,010
dentro da caixa preta para
produzir uma única saída.

46
00:02:01,010 --> 00:02:05,190
Portanto, neste caso, se
adicionar leva de 3, 6, e 7.

47
00:02:05,190 --> 00:02:07,020
Em algum lugar dentro do
adicionar a função, faríamos

48
00:02:07,020 --> 00:02:09,750
esperar que eles sejam adicionados em conjunto
para produzir a saída, que

49
00:02:09,750 --> 00:02:13,220
é 3 mais 6 mais 7 ou 16.

50
00:02:13,220 --> 00:02:17,940
>> Da mesma forma, você tem uma função chamada
mult que leva duas entradas, a e b,

51
00:02:17,940 --> 00:02:21,070
processa-los de alguma forma, tais
que a saída da função

52
00:02:21,070 --> 00:02:22,920
é o produto das duas entradas.

53
00:02:22,920 --> 00:02:25,080
As duas entradas multiplicados juntos.

54
00:02:25,080 --> 00:02:29,150
4 e 5 sendo passado para mult,
algo acontece, a saída esperamos

55
00:02:29,150 --> 00:02:31,090
é 20.

56
00:02:31,090 --> 00:02:32,507
Por que chamá-lo de uma caixa preta?

57
00:02:32,507 --> 00:02:34,840
Bem, se nós não estamos escrevendo o
Funciona nós mesmos, o que

58
00:02:34,840 --> 00:02:36,869
nós fizemos um pouco até agora CS50.

59
00:02:36,869 --> 00:02:39,910
Nós vimos de impressão f, por exemplo, que
é uma função que nós não escrevemos

60
00:02:39,910 --> 00:02:42,305
nós mesmos, mas nós usar o tempo todo.

61
00:02:42,305 --> 00:02:44,180
Se não estamos escrevendo
as funções de nós mesmos,

62
00:02:44,180 --> 00:02:48,450
nós realmente não precisa saber como é
realmente implementada sob o capô.

63
00:02:48,450 --> 00:02:51,710
>> Assim, por exemplo a caixa preta I
acabei de mostrar para a multiplicação,

64
00:02:51,710 --> 00:02:53,740
mult a, b poderiam ser
defined-- e este é apenas

65
00:02:53,740 --> 00:02:57,902
poderia ser algum pseudocode--
definida como uma saída vezes b.

66
00:02:57,902 --> 00:02:58,860
Isso faz sentido, certo.

67
00:02:58,860 --> 00:03:01,370
Se temos uma função chamada
mult que leva duas entradas.

68
00:03:01,370 --> 00:03:04,750
Seria de esperar que a saída seria
ser as duas entradas multiplicados juntos,

69
00:03:04,750 --> 00:03:06,240
um vezes b.

70
00:03:06,240 --> 00:03:09,170
Mas também podia ser mult
implementado como este,

71
00:03:09,170 --> 00:03:13,150
temos uma variável de contador para
prepare-se para dentro de mult a 0.

72
00:03:13,150 --> 00:03:18,000
E, depois, repetir este processo
b vezes adicionar ao contador.

73
00:03:18,000 --> 00:03:24,270
Por exemplo, se multiplicarmos por 3a
5b, poderíamos dizer definir contador a 0,

74
00:03:24,270 --> 00:03:27,700
Repita cinco vezes, adicionar 3 a balcão.

75
00:03:27,700 --> 00:03:34,490
Então, vamos começar em 0 e então nós fazemos
isso cinco vezes 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
É o mesmo resultado. Nós
ainda obter 3 vezes apenas 5

77
00:03:37,500 --> 00:03:39,500
a aplicação é diferente.

78
00:03:39,500 --> 00:03:41,490
>> Isso é o que queremos dizer
quando dizemos que uma caixa preta.

79
00:03:41,490 --> 00:03:44,406
Significa apenas que nós realmente não me importo
como ele é implementado sob o capô

80
00:03:44,406 --> 00:03:46,170
desde que a saída é o que se espera.

81
00:03:46,170 --> 00:03:49,045
Na verdade, isso é parte do contrato
do uso de funções, particularmente

82
00:03:49,045 --> 00:03:50,630
funções que os outros escrevem.

83
00:03:50,630 --> 00:03:53,980
O comportamento é sempre vai
ser típico, imprevisível

84
00:03:53,980 --> 00:03:55,420
com base no nome da função.

85
00:03:55,420 --> 00:03:57,500
E é por isso que é realmente
importante quando você escrever funções

86
00:03:57,500 --> 00:04:00,020
ou quando outras pessoas escrever
funções que você pode usar,

87
00:04:00,020 --> 00:04:03,590
aqueles que têm funções
nomes claros e relativamente óbvias,

88
00:04:03,590 --> 00:04:04,990
e estão bem documentados.

89
00:04:04,990 --> 00:04:08,560
Que é certamente o caso
para a função de impressão como f.

90
00:04:08,560 --> 00:04:09,860
>> Então, por que usar funções?

91
00:04:09,860 --> 00:04:14,220
Bem, como eu disse anteriormente, se escrevermos
todo o nosso código dentro das coisas principais

92
00:04:14,220 --> 00:04:17,120
pode ficar muito pesado
e realmente complicado.

93
00:04:17,120 --> 00:04:19,980
Funções-nos permitir que a capacidade
para organizar as coisas e acabar com

94
00:04:19,980 --> 00:04:24,540
um problema muito complicado em
um monte sub partes mais gerenciáveis.

95
00:04:24,540 --> 00:04:28,130
Funções também nos permitem
simplificar o processo de codificação.

96
00:04:28,130 --> 00:04:33,080
É muito mais fácil de depurar a 10
função de linha versus uma linha 100

97
00:04:33,080 --> 00:04:35,890
função ou uma função 1000 line.

98
00:04:35,890 --> 00:04:38,400
Se só temos de debug
pequenos pedaços de cada vez,

99
00:04:38,400 --> 00:04:42,110
ou escrever pequenos pedaços no momento,
faz que a experiência de programação

100
00:04:42,110 --> 00:04:43,070
muito melhor.

101
00:04:43,070 --> 00:04:44,910
Confie em mim sobre isso.

102
00:04:44,910 --> 00:04:48,400
>> Por último, se escrevermos funções que
pode reutilizar essas várias partes.

103
00:04:48,400 --> 00:04:49,880
As funções podem ser reciclados.

104
00:04:49,880 --> 00:04:51,880
Eles podem ser utilizados em
um ou outro programa.

105
00:04:51,880 --> 00:04:53,713
Você já escreveu
a função, tudo que você

106
00:04:53,713 --> 00:04:56,530
precisa fazer é dizer que o programa
onde encontrar essa função.

107
00:04:56,530 --> 00:04:59,680
Temos vindo a reciclagem e utilização de
imprimir f há mais de 40 anos.

108
00:04:59,680 --> 00:05:02,150
Mas ela só foi escrita uma vez.

109
00:05:02,150 --> 00:05:04,270
Bastante útil, certo.

110
00:05:04,270 --> 00:05:04,830
Tudo certo.

111
00:05:04,830 --> 00:05:06,040
Assim, as funções são grandes.

112
00:05:06,040 --> 00:05:06,860
Nós sabemos isso.

113
00:05:06,860 --> 00:05:08,700
Agora vamos começar a escrevê-los.

114
00:05:08,700 --> 00:05:10,830
Vamos começar a receber
-los em nossos programas.

115
00:05:10,830 --> 00:05:13,869
A fim de fazer isso, o primeiro
coisa que fazemos é declarar a função.

116
00:05:13,869 --> 00:05:16,160
Quando você declarar uma função
o que está fazendo, basicamente,

117
00:05:16,160 --> 00:05:18,900
está dizendo o compilador,
hey, só para você saber,

118
00:05:18,900 --> 00:05:20,850
Estou indo para ser escrito
uma função mais tarde

119
00:05:20,850 --> 00:05:22,987
e aqui está o que ele vai olhar como.

120
00:05:22,987 --> 00:05:24,820
A razão para isto é
porque compiladores puder

121
00:05:24,820 --> 00:05:27,900
fazer algumas coisas estranhas, se
eles vêem um conjunto de símbolos

122
00:05:27,900 --> 00:05:29,560
que eles não estão familiarizados.

123
00:05:29,560 --> 00:05:33,000
Então, nós apenas dar o compilador um
heads-up, eu estou criando uma função

124
00:05:33,000 --> 00:05:35,492
e ele vai fazer isso.

125
00:05:35,492 --> 00:05:38,450
Declarações de função geralmente se
você está organizando seu código de uma maneira

126
00:05:38,450 --> 00:05:41,872
que os outros será capaz de
compreender e fazer uso,

127
00:05:41,872 --> 00:05:44,330
você geralmente deseja colocar tudo
de suas declarações de função

128
00:05:44,330 --> 00:05:48,220
no topo do seu código, direita
antes de começar a escrever principal mesmo.

129
00:05:48,220 --> 00:05:50,770
E convenientemente, há
uma forma muito normal

130
00:05:50,770 --> 00:05:53,500
que cada declaração de função segue.

131
00:05:53,500 --> 00:05:56,090
Todos eles muito bem parecido com este.

132
00:05:56,090 --> 00:06:01,440
Há três partes para uma função
declaração, tipo de retorno, nome,

133
00:06:01,440 --> 00:06:03,420
e lista de argumentos.

134
00:06:03,420 --> 00:06:07,180
>> Agora, o tipo de retorno é o tipo de
variável a saída da função vontade.

135
00:06:07,180 --> 00:06:10,710
Assim, por exemplo, se pensarmos de volta um
minuto atrás para a multiplicação de dois

136
00:06:10,710 --> 00:06:15,690
números de função, o que esperamos se
multiplicarmos um número inteiro por um número inteiro

137
00:06:15,690 --> 00:06:18,502
a saída será
provavelmente um número inteiro, certo.

138
00:06:18,502 --> 00:06:20,710
Multiplicado dois inteiros
juntos, você obtém um número inteiro.

139
00:06:20,710 --> 00:06:24,167
Assim, o tipo de retorno que
função seria int.

140
00:06:24,167 --> 00:06:26,000
Nome é o que você quer
para chamar sua função.

141
00:06:26,000 --> 00:06:29,330
Este é provavelmente o menos importante
parte da declaração de função,

142
00:06:29,330 --> 00:06:30,827
em termos de funcionalidade.

143
00:06:30,827 --> 00:06:33,160
Mas é, na verdade, provavelmente, um
das partes mais importantes

144
00:06:33,160 --> 00:06:36,243
da declaração da função em termos
de saber o que a função realmente

145
00:06:36,243 --> 00:06:37,120
faz.

146
00:06:37,120 --> 00:06:40,474
Se você nomear sua função f ou g ou
h ou mistério ou algo parecido,

147
00:06:40,474 --> 00:06:42,765
você provavelmente vai conseguir
um pouco tropeçou tentando

148
00:06:42,765 --> 00:06:44,650
para lembrar o que fazer essas funções.

149
00:06:44,650 --> 00:06:47,880
Por isso, é importante dar o seu
nomes significativos da função.

150
00:06:47,880 --> 00:06:51,030
>> Por último, lista de argumentos está
a lista separada por vírgulas

151
00:06:51,030 --> 00:06:55,260
de todas as entradas para a sua função,
cada um dos quais tem um tipo e um nome.

152
00:06:55,260 --> 00:06:57,840
Portanto, não só você tem que
especificar o tipo de variável

153
00:06:57,840 --> 00:07:00,760
a saída da função vontade,
você também deseja especificar

154
00:07:00,760 --> 00:07:07,694
que tipo e tipos de variáveis ​​as
função será aceitar como entradas.

155
00:07:07,694 --> 00:07:08,860
Então vamos fazer um exemplo aqui.

156
00:07:08,860 --> 00:07:10,220
Vamos apenas dar uma olhada
em uma forma mais concreta.

157
00:07:10,220 --> 00:07:13,130
Então aqui está um exemplo de uma função
declaração de que uma função

158
00:07:13,130 --> 00:07:14,925
gostaria de acrescentar dois inteiros juntos.

159
00:07:14,925 --> 00:07:17,800
A soma dos dois inteiros vai
ser um inteiro também, como acabamos

160
00:07:17,800 --> 00:07:18,450
discutidos.

161
00:07:18,450 --> 00:07:21,610
E assim o tipo de retorno,
aqui em verde, seria int.

162
00:07:21,610 --> 00:07:25,190
Isso só nos que adicionar dois ints diz
vai, no final do dia,

163
00:07:25,190 --> 00:07:28,799
de saída, ou cuspir de volta
para nós, um número inteiro.

164
00:07:28,799 --> 00:07:31,590
Dado que esta função faz nós
quero dar-lhe um nome significativo.

165
00:07:31,590 --> 00:07:33,630
Adicione dois ints parece
apropriada, considerando-se

166
00:07:33,630 --> 00:07:37,574
nós estamos levando dois inteiros como insumos
e espero que juntá-las.

167
00:07:37,574 --> 00:07:40,240
Pode ser um pouco de um incómodo
nome e, francamente, esta função

168
00:07:40,240 --> 00:07:42,430
Provavelmente não é necessário
uma vez que temos a adição

169
00:07:42,430 --> 00:07:46,310
operador, se você se lembra da nossa
discussão dos operadores, anteriormente.

170
00:07:46,310 --> 00:07:49,650
Mas vamos apenas dizer que por causa de
argumento de que esta função é útil

171
00:07:49,650 --> 00:07:52,860
e por isso vamos chamá-lo de adicionar dois ints.

172
00:07:52,860 --> 00:07:55,230
Por último, esta função tem duas entradas.

173
00:07:55,230 --> 00:07:56,960
Cada um dos quais é um número inteiro.

174
00:07:56,960 --> 00:07:59,900
Então nós temos essa vírgula
lista separada de entradas.

175
00:07:59,900 --> 00:08:02,830
Agora nós geralmente querem
dar um nome de cada uma delas

176
00:08:02,830 --> 00:08:05,070
de modo que eles podem ser usados
dentro da função.

177
00:08:05,070 --> 00:08:07,180
Os nomes não são terrivelmente importante.

178
00:08:07,180 --> 00:08:11,400
>> Neste caso, nós não necessariamente
tem algum significado a elas associadas.

179
00:08:11,400 --> 00:08:13,140
Assim, podemos apenas chamar-lhes a e b.

180
00:08:13,140 --> 00:08:14,257
Isso é totalmente bom.

181
00:08:14,257 --> 00:08:16,090
Se, no entanto, você encontrar
se em uma situação

182
00:08:16,090 --> 00:08:19,497
onde os nomes das variáveis
pode ser realmente importante,

183
00:08:19,497 --> 00:08:21,830
você pode querer chamá-los
algo que não seja a e b

184
00:08:21,830 --> 00:08:24,701
para dar-lhes algo mais
simbolicamente significativa.

185
00:08:24,701 --> 00:08:27,700
Mas, neste caso, nós realmente não
saber mais alguma coisa sobre a função.

186
00:08:27,700 --> 00:08:29,320
Nós só queremos adicionar dois inteiros.

187
00:08:29,320 --> 00:08:32,429
Então vamos chamá
os números inteiros a e b.

188
00:08:32,429 --> 00:08:33,990
Isso é um exemplo.

189
00:08:33,990 --> 00:08:36,287
>> Por que você não tomar uma segunda
para pensar sobre este,

190
00:08:36,287 --> 00:08:38,870
como você escrever uma função
declaração de que uma função

191
00:08:38,870 --> 00:08:42,940
Multiplica dois números de ponto flutuante?

192
00:08:42,940 --> 00:08:45,910
Você se lembra o que um
número de ponto flutuante é?

193
00:08:45,910 --> 00:08:48,120
O que seria essa função
declaração parece?

194
00:08:48,120 --> 00:08:53,330
Na verdade, eu recomendo que você pausar o vídeo
aqui e levar quanto tempo você precisa.

195
00:08:53,330 --> 00:08:55,521
Pense sobre o que esta
declaração de função seria?

196
00:08:55,521 --> 00:08:56,770
Qual seria o tipo de retorno ser?

197
00:08:56,770 --> 00:08:58,103
O que seria um nome significativo ser?

198
00:08:58,103 --> 00:08:59,580
Quais seriam as entradas de ser?

199
00:08:59,580 --> 00:09:03,190
Então, por que você não interromper o vídeo aqui
e escrever-se uma declaração de função

200
00:09:03,190 --> 00:09:07,640
para uma função que multiplicaria
dois números de ponto flutuante em conjunto.

201
00:09:07,640 --> 00:09:09,330
Esperamos que você parou o vídeo.

202
00:09:09,330 --> 00:09:12,950
>> Então vamos dar uma olhada em um exemplo
de uma declaração possível.

203
00:09:12,950 --> 00:09:17,340
Float mult dois reais flutuam x, y flutuador.

204
00:09:17,340 --> 00:09:19,090
O produto de dois
números de ponto flutuante,

205
00:09:19,090 --> 00:09:21,710
recordar que são como nós
representam números reais

206
00:09:21,710 --> 00:09:26,770
ou números com valores decimais em c,
vai ser um número de ponto flutuante.

207
00:09:26,770 --> 00:09:28,570
Quando você multiplica um
decimal por um decimal,

208
00:09:28,570 --> 00:09:30,460
provavelmente você está indo para obter um decimal.

209
00:09:30,460 --> 00:09:31,960
Você quer dar-lhe um nome relevante.

210
00:09:31,960 --> 00:09:33,810
Multiplique dois reais parece bem.

211
00:09:33,810 --> 00:09:36,620
Mas você poderia realmente chamá-lo
mult dois carros alegóricos, ou flutuadores mult.

212
00:09:36,620 --> 00:09:39,540
Qualquer coisa assim, contanto que
deu algum significado real ao que

213
00:09:39,540 --> 00:09:41,469
essa caixa preta ia fazer.

214
00:09:41,469 --> 00:09:44,260
E mais uma vez, neste caso, nós não
parece ter qualquer significado ligado

215
00:09:44,260 --> 00:09:46,390
para os nomes dos
variáveis ​​que estamos passando em,

216
00:09:46,390 --> 00:09:48,645
por isso, só chamá-los de x e y.

217
00:09:48,645 --> 00:09:51,020
Agora, se você chamá-los de algo
outra coisa, isso é totalmente bom.

218
00:09:51,020 --> 00:09:53,310
Na verdade, se você fez
esta declaração em vez

219
00:09:53,310 --> 00:09:55,450
usando em vez de duplas
de carros alegóricos, se você se lembra

220
00:09:55,450 --> 00:09:59,100
duplos que são uma diferente
maneira a mais precisamente

221
00:09:59,100 --> 00:10:02,330
especificar números reais ou
flutuante variáveis ​​de ponto.

222
00:10:02,330 --> 00:10:03,620
Isso é totalmente bem também.

223
00:10:03,620 --> 00:10:04,670
Ou um daqueles seria ótimo.

224
00:10:04,670 --> 00:10:06,711
Na verdade, existem vários
combinações diferentes

225
00:10:06,711 --> 00:10:08,410
de maneiras de declarar esta função.

226
00:10:08,410 --> 00:10:10,884
Mas estes são dois muito bons.

227
00:10:10,884 --> 00:10:12,550
Temos declarada uma função, isso é ótimo.

228
00:10:12,550 --> 00:10:15,700
Dissemos o que o compilador
é, o que vamos fazer.

229
00:10:15,700 --> 00:10:17,630
Agora vamos realmente escrever essa função.

230
00:10:17,630 --> 00:10:20,750
Vamos dar-lhe uma definição,
de modo que dentro da caixa preta

231
00:10:20,750 --> 00:10:22,840
comportamento previsível está acontecendo.

232
00:10:22,840 --> 00:10:26,270
Na verdade, estamos multiplicando dois reais
números, ou acrescentando números

233
00:10:26,270 --> 00:10:29,760
juntos, ou fazendo o que quer que seja
que pedimos a nossa função fazer.

234
00:10:29,760 --> 00:10:32,780
>> Então, na verdade, vamos tentar definir
multiplicar dois reais que acabamos

235
00:10:32,780 --> 00:10:35,350
falou sobre um segundo atrás.

236
00:10:35,350 --> 00:10:38,560
Agora, o início de
a definição de função

237
00:10:38,560 --> 00:10:41,720
parece quase exatamente o mesmo
como uma declaração de função.

238
00:10:41,720 --> 00:10:43,170
Eu tenho os dois aqui.

239
00:10:43,170 --> 00:10:47,770
No topo está a declaração de função,
tipo, nome, argumento separados por vírgulas

240
00:10:47,770 --> 00:10:49,410
lista, ponto e vírgula.

241
00:10:49,410 --> 00:10:53,800
A vírgula indica que
que é uma declaração de função.

242
00:10:53,800 --> 00:10:57,060
O início da função
definição parece quase exatamente

243
00:10:57,060 --> 00:11:03,790
o mesmo, tipo, nome, separados por vírgulas
lista de argumentos, sem ponto e vírgula,

244
00:11:03,790 --> 00:11:05,206
abrir chaveta.

245
00:11:05,206 --> 00:11:07,580
A chave de abertura, assim como
temos vindo a fazer com o principal,

246
00:11:07,580 --> 00:11:09,540
significa que estamos agora
começando a definir

247
00:11:09,540 --> 00:11:14,567
o que acontece no interior da caixa preta que
nós decidimos chamar mult dois reais.

248
00:11:14,567 --> 00:11:15,900
Aqui está uma maneira de implementá-lo.

249
00:11:15,900 --> 00:11:20,370
Poderíamos dizer, poderíamos declarar uma nova
variável do tipo float chamado produto

250
00:11:20,370 --> 00:11:24,020
e atribuir essa variável
para o valor x vezes y.

251
00:11:24,020 --> 00:11:27,306
E, em seguida, devolver o produto.

252
00:11:27,306 --> 00:11:28,430
O que significa retorno aqui.

253
00:11:28,430 --> 00:11:31,090
Bem retorno é o caminho
que indicam que é assim

254
00:11:31,090 --> 00:11:33,400
nós estamos passando a saída de volta para fora.

255
00:11:33,400 --> 00:11:38,160
Assim retornar algo, é o mesmo que,
esta é a saída da caixa preta.

256
00:11:38,160 --> 00:11:40,732
Então, isso é como fazê-lo.

257
00:11:40,732 --> 00:11:42,190
Aqui está outra maneira de implementá-lo.

258
00:11:42,190 --> 00:11:45,050
Nós poderíamos apenas retornar x vezes y.

259
00:11:45,050 --> 00:11:45,870
x é um float.

260
00:11:45,870 --> 00:11:46,660
y é um float.

261
00:11:46,660 --> 00:11:48,490
Então x vezes y também é um float.

262
00:11:48,490 --> 00:11:50,750
Nós nem sequer precisa
criar uma outra variável.

263
00:11:50,750 --> 00:11:56,750
Então essa é uma maneira diferente de
implementar a mesma caixa preta exata.

264
00:11:56,750 --> 00:11:58,570
>> Agora pegue um momento,
pausar o vídeo novamente,

265
00:11:58,570 --> 00:12:01,680
e tentar definir adicionar dois ints,
que é a outra função que nós

266
00:12:01,680 --> 00:12:03,090
falou sobre um momento atrás.

267
00:12:03,090 --> 00:12:06,440
Mais uma vez aqui, eu coloquei a função
declaração, e assim o ponto e vírgula,

268
00:12:06,440 --> 00:12:08,420
e uma chaveta aberta
e um encaracolado fechado

269
00:12:08,420 --> 00:12:12,080
cinta para indicar onde vamos encher
no conteúdo de adicionar dois ints,

270
00:12:12,080 --> 00:12:15,530
de modo que se define o particular
comportamento dentro da caixa negra.

271
00:12:15,530 --> 00:12:16,380
Então, pausar o vídeo.

272
00:12:16,380 --> 00:12:18,790
E tirar o máximo de tempo
você precisa tentar e definir

273
00:12:18,790 --> 00:12:25,040
uma implementação de adicionar dois ints, tais
que quando da função gera um valor,

274
00:12:25,040 --> 00:12:29,209
isso acontece, na verdade, de retorno
a soma das duas entradas.

275
00:12:29,209 --> 00:12:32,000
Assim como no exemplo anterior,
há várias maneiras diferentes

276
00:12:32,000 --> 00:12:34,210
que você poderia implementar adicionar dois ints.

277
00:12:34,210 --> 00:12:35,130
Aqui está um.

278
00:12:35,130 --> 00:12:37,172
Em aqui em laranja tenho
só tinha alguns comments--

279
00:12:37,172 --> 00:12:38,880
Eu apenas adicionei alguns
Comentários para indicar

280
00:12:38,880 --> 00:12:41,400
o que está acontecendo em cada linha de código.

281
00:12:41,400 --> 00:12:45,430
Então eu declarar uma variável
chamada soma do tipo int.

282
00:12:45,430 --> 00:12:47,279
Eu digo soma é igual a mais b.

283
00:12:47,279 --> 00:12:50,070
É aí que está realmente fazendo
a adição de um trabalho e B em conjunto.

284
00:12:50,070 --> 00:12:51,850
E eu voltar soma.

285
00:12:51,850 --> 00:12:56,460
E isso faz sentido, porque
soma é uma variável do tipo int.

286
00:12:56,460 --> 00:13:00,180
E qual é o tipo de dados que este
função diz-me que vai para a saída?

287
00:13:00,180 --> 00:13:00,680
Int.

288
00:13:00,680 --> 00:13:03,072
Então, eu estou voltando soma, que
é uma variável inteira.

289
00:13:03,072 --> 00:13:06,030
E isso faz sentido, dado o que nós temos
declarada e definida a nossa função

290
00:13:06,030 --> 00:13:07,320
fazer.

291
00:13:07,320 --> 00:13:09,700
>> Agora você também pode definir
a função desta forma,

292
00:13:09,700 --> 00:13:15,260
int soma é igual a um plus B-- pular essa
step-- primeiro e, em seguida, retornar soma.

293
00:13:15,260 --> 00:13:17,760
Agora você pode ter também
implementou-lo desta maneira,

294
00:13:17,760 --> 00:13:19,180
que eu altamente não recomendo.

295
00:13:19,180 --> 00:13:22,540
Isso é ruim para um estilo
coisa muito ruim e design,

296
00:13:22,540 --> 00:13:24,420
mas ele faz, de fato, o trabalho.

297
00:13:24,420 --> 00:13:30,199
Se você tomar este código, que é int
adicionar ruim víbora ponto c, e usá-lo.

298
00:13:30,199 --> 00:13:31,990
Ele realmente não adicionar
dois inteiros juntos.

299
00:13:31,990 --> 00:13:37,632
É uma aplicação muito pobre
deste comportamento particular.

300
00:13:37,632 --> 00:13:38,340
Mas ele não funciona.

301
00:13:38,340 --> 00:13:41,200
É apenas para ilustrar
o ponto que nós realmente não

302
00:13:41,200 --> 00:13:44,530
importo com o que acontece dentro
a caixa preta, contanto

303
00:13:44,530 --> 00:13:46,510
uma vez que tem a saída que esperamos.

304
00:13:46,510 --> 00:13:48,870
Esta é uma caixa preta mal projetado.

305
00:13:48,870 --> 00:13:53,801
Mas no final do dia, ele faz
saída ainda a soma de a mais b.

306
00:13:53,801 --> 00:13:54,300
Tudo certo.

307
00:13:54,300 --> 00:13:56,320
Então, nós temos funções declarou.

308
00:13:56,320 --> 00:13:57,490
E nós função definida.

309
00:13:57,490 --> 00:13:58,540
Então, isso é muito bom.

310
00:13:58,540 --> 00:14:03,020
Agora vamos começar a usar as funções
que já declarou e nós definimos.

311
00:14:03,020 --> 00:14:05,960
Para chamar um function-- é realmente
muito easy-- tudo o que você precisa fazer

312
00:14:05,960 --> 00:14:09,070
é passá-lo argumentos apropriados,
argumentos do tipo de dados

313
00:14:09,070 --> 00:14:11,600
que espera, e
em seguida, atribuir o retorno

314
00:14:11,600 --> 00:14:15,190
valor dessa função
e isto-- desculpa me--

315
00:14:15,190 --> 00:14:19,390
atribuir o valor de retorno dessa função
a algo do tipo correto.

316
00:14:19,390 --> 00:14:22,410
>> Então vamos dar uma olhada
isso na prática em um arquivo

317
00:14:22,410 --> 00:14:27,730
chamado víbora 1 ponto c, que
Eu tenho no meu CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Então aqui está víbora 1 ponto c.

319
00:14:31,042 --> 00:14:33,500
No início vedes que eu tenho
minha inclui, libra incluem,

320
00:14:33,500 --> 00:14:35,460
IO padrão, e CS50 dot h.

321
00:14:35,460 --> 00:14:37,700
E então eu tenho a minha declaração de função.

322
00:14:37,700 --> 00:14:39,570
Este é o lugar onde eu estou
dizendo que eu sou o compilador

323
00:14:39,570 --> 00:14:42,850
vai estar escrevendo um
função chamada adicionar dois ints.

324
00:14:42,850 --> 00:14:45,780
Vai uma saída
variável do tipo integer.

325
00:14:45,780 --> 00:14:47,360
Isso é o que esta parte é aqui mesmo.

326
00:14:47,360 --> 00:14:51,950
E então eu tenho duas entradas para que uma
e b, cada um dos quais é um número inteiro.

327
00:14:51,950 --> 00:14:58,250
Dentro do principal, eu perguntar ao usuário
entrada dizendo, me dar um inteiro.

328
00:14:58,250 --> 00:15:01,040
E eles são solicitados para esquecer
int, que é uma função que

329
00:15:01,040 --> 00:15:03,240
está incluída na biblioteca CS50.

330
00:15:03,240 --> 00:15:07,660
E isso fica armazenado em
x, uma variável inteira.

331
00:15:07,660 --> 00:15:09,886
>> Em seguida, levá-los para um outro número inteiro.

332
00:15:09,886 --> 00:15:13,070
Ficamos com outro inteiro
e armazenar que em y.

333
00:15:13,070 --> 00:15:17,990
E então, aqui na linha 28, é
onde fazemos a nossa chamada de função.

334
00:15:17,990 --> 00:15:23,770
Estamos dizendo, iguais int z
adicionar 2 ints x vírgula y.

335
00:15:23,770 --> 00:15:25,980
Você percebe por que isso faz sentido?

336
00:15:25,980 --> 00:15:29,710
x é uma variável do tipo inteiro e
y é uma variável do tipo inteiro.

337
00:15:29,710 --> 00:15:31,220
Então, isso é bom.

338
00:15:31,220 --> 00:15:34,570
Isso faz sentido com o que a nossa função
declaração na linha 17 parece.

339
00:15:34,570 --> 00:15:38,300
A lista de entrada separados por vírgulas
espera dois números inteiros, a e b.

340
00:15:38,300 --> 00:15:40,300
Nesse caso, podemos chamá-
eles o que nós queremos.

341
00:15:40,300 --> 00:15:42,300
Ele só espera dois números inteiros.

342
00:15:42,300 --> 00:15:44,930
E X é um número inteiro e y é um número inteiro.

343
00:15:44,930 --> 00:15:45,640
Isso funciona.

344
00:15:45,640 --> 00:15:48,680
>> E nós sabemos que a função está acontecendo
para produzir um inteiros bem.

345
00:15:48,680 --> 00:15:51,290
E assim estamos armazenando o
saída da função,

346
00:15:51,290 --> 00:15:56,050
adicionar dois ints, em um tipo inteiro
variável, que estamos chamando z.

347
00:15:56,050 --> 00:16:01,980
E então podemos dizer, a soma de
i por cento por cento e é por cento i i.

348
00:16:01,980 --> 00:16:06,210
x, y e z, respectivamente,
preenchendo os i de por cento.

349
00:16:06,210 --> 00:16:08,334
Qual é a definição de
adicionar dois ints parece?

350
00:16:08,334 --> 00:16:09,125
É muito simples.

351
00:16:09,125 --> 00:16:11,270
É um dos nós
só vi um segundo atrás,

352
00:16:11,270 --> 00:16:14,390
int soma é igual a um montante acrescido b retorno.

353
00:16:14,390 --> 00:16:15,420
Isto funciona?

354
00:16:15,420 --> 00:16:17,270
Vamos salvar o arquivo.

355
00:16:17,270 --> 00:16:22,080
E, em seguida, para baixo aqui no meu terminal
Eu vou fazer uma víbora,

356
00:16:22,080 --> 00:16:23,000
e eu limpar minha tela.

357
00:16:23,000 --> 00:16:25,791
Eu estou indo para aumentar o zoom, porque eu sei
é um pouco difícil de ver.

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> Então, nós compilar este programa como uma víbora.

360
00:16:33,770 --> 00:16:37,910
Então o que podemos fazer dot barra víbora 1.

361
00:16:37,910 --> 00:16:40,060
Dê-me um número inteiro, 10.

362
00:16:40,060 --> 00:16:42,380
Dê-me outro inteiro, 20.

363
00:16:42,380 --> 00:16:45,200
A soma de 10 e 20 é de 30.

364
00:16:45,200 --> 00:16:47,615
Por isso, fizemos uma chamada de função bem sucedida.

365
00:16:47,615 --> 00:16:55,820
Você pode executar a função novamente, negativo
10, 17 soma negativa de 10 e 17 é de 7.

366
00:16:55,820 --> 00:16:57,120
Esta função funciona.

367
00:16:57,120 --> 00:16:59,240
Tem o comportamento
que esperamos que ele.

368
00:16:59,240 --> 00:17:03,610
E assim fizemos uma bem-sucedida
função, definição, declaração,

369
00:17:03,610 --> 00:17:07,288
e uma chamada de função bem sucedida.

370
00:17:07,288 --> 00:17:09,079
Casal variado
pontos sobre funções

371
00:17:09,079 --> 00:17:10,611
antes de concluir esta seção.

372
00:17:10,611 --> 00:17:12,319
Recordar da nossa
discussão de tipos de dados,

373
00:17:12,319 --> 00:17:16,109
anteriormente, que funciona
às vezes pode demorar há entradas.

374
00:17:16,109 --> 00:17:17,930
Se for esse o caso,
declarar a função

375
00:17:17,930 --> 00:17:19,788
como tendo uma lista de argumentos vazio.

376
00:17:19,788 --> 00:17:21,579
Você se lembra o que o
mais função comum

377
00:17:21,579 --> 00:17:25,036
temos visto até agora que leva
uma lista de argumentos é nulo?

378
00:17:25,036 --> 00:17:27,300
É principal.

379
00:17:27,300 --> 00:17:30,850
Lembre-se também que a função às vezes
realmente não tem uma saída.

380
00:17:30,850 --> 00:17:34,210
Nesse caso, nós declaramos a função
como tendo um tipo de retorno void.

381
00:17:34,210 --> 00:17:37,880
Vamos concluir esta seção
enfrentar um problema prática.

382
00:17:37,880 --> 00:17:39,900
>> Então aqui está o problema colocado para fora.

383
00:17:39,900 --> 00:17:43,630
Eu quero que você escrever uma função
chamado triângulo válido.

384
00:17:43,630 --> 00:17:47,410
O que esta função deve fazer
é tomar três números reais

385
00:17:47,410 --> 00:17:51,930
que representam os comprimentos dos três
lados de um triângulo como os seus parâmetros,

386
00:17:51,930 --> 00:17:54,550
ou seus argumentos, ou a sua
Insumos outro conjunto de sinônimos

387
00:17:54,550 --> 00:17:57,340
que você pode encontrar.

388
00:17:57,340 --> 00:18:01,120
Esta função deve
quer saída de verdadeiro ou falso

389
00:18:01,120 --> 00:18:04,960
dependendo se estes três comprimentos
são capazes de fazer um triângulo.

390
00:18:04,960 --> 00:18:09,930
Você se lembra do tipo de dados que
nós usado para indicar verdadeiro ou falso?

391
00:18:09,930 --> 00:18:11,436
Agora, como você implementar isso?

392
00:18:11,436 --> 00:18:13,810
Bem sei que há um casal
de regras relativas triângulos

393
00:18:13,810 --> 00:18:15,480
que são realmente úteis para saber.

394
00:18:15,480 --> 00:18:18,292
Um triângulo só pode ter
lados com comprimento positivo.

395
00:18:18,292 --> 00:18:19,000
Isso faz sentido.

396
00:18:19,000 --> 00:18:21,432
Você provavelmente está dizendo, duh.

397
00:18:21,432 --> 00:18:23,390
A outra coisa a notar
no entanto, é que a soma

398
00:18:23,390 --> 00:18:25,484
dos comprimentos de qualquer
dois lados do triângulo

399
00:18:25,484 --> 00:18:27,650
tem de ser maior do que o
comprimento do terceiro lado.

400
00:18:27,650 --> 00:18:28,690
Isso é realmente verdade.

401
00:18:28,690 --> 00:18:34,150
Você não pode ter um triângulo de lados 1,
2 e 4, por exemplo, por 1 mais 2

402
00:18:34,150 --> 00:18:36,270
não é maior do que 4.

403
00:18:36,270 --> 00:18:38,870
Portanto, estas são as regras que
determinar se ou não a três

404
00:18:38,870 --> 00:18:42,740
entradas podem concebivelmente formar um triângulo.

405
00:18:42,740 --> 00:18:46,360
Então, tome um par de minutos
e declarar e, em seguida, definir

406
00:18:46,360 --> 00:18:49,810
esta função chamada válido
triângulo, de tal modo que ela realmente

407
00:18:49,810 --> 00:18:51,650
tem o comportamento especificado aqui.

408
00:18:51,650 --> 00:18:57,030
>> Ele irá imprimir verdadeira se esses três lados
são capazes de que compreende um triângulo,

409
00:18:57,030 --> 00:19:01,950
e falso caso contrário
Pronto para ver como você fez?

410
00:19:01,950 --> 00:19:04,650
Aqui está uma implementação
triângulo de válido.

411
00:19:04,650 --> 00:19:05,770
Não é o único.

412
00:19:05,770 --> 00:19:07,770
O seu pode variar um pouco.

413
00:19:07,770 --> 00:19:11,040
Mas isso se faz, de fato, têm
o comportamento que esperamos.

414
00:19:11,040 --> 00:19:14,450
Declaramos nossa função no
topo, bool triângulo válido

415
00:19:14,450 --> 00:19:16,630
flutuar x flutuador flutuador y z.

416
00:19:16,630 --> 00:19:18,930
Então, novamente, esta função
leva três números reais

417
00:19:18,930 --> 00:19:22,280
como seus argumentos, flutuante
variáveis ​​de valor ponto,

418
00:19:22,280 --> 00:19:26,510
e emite um verdadeiro ou falso
valor, que é um valor booleano, recall.

419
00:19:26,510 --> 00:19:28,660
É por isso que o tipo de retorno é bool.

420
00:19:28,660 --> 00:19:30,016
Em seguida, definir a função.

421
00:19:30,016 --> 00:19:33,140
A primeira coisa que fazemos é verificar para se certificar
que todos os lados são positivos.

422
00:19:33,140 --> 00:19:37,010
Se X é menor ou igual
a 0, ou, se y é igual a 0,

423
00:19:37,010 --> 00:19:41,050
ou, se Z for inferior ou igual a 0,
que não pode possivelmente ser um triângulo.

424
00:19:41,050 --> 00:19:42,380
Eles não têm lados positivos.

425
00:19:42,380 --> 00:19:45,790
E assim podemos voltar
false nessa situação.

426
00:19:45,790 --> 00:19:49,010
Em seguida, vamos verificar para se certificar
que cada par de entradas

427
00:19:49,010 --> 00:19:51,830
é maior do que a terceira.

428
00:19:51,830 --> 00:19:54,530
>> Assim, se x mais y é menos
que ou igual a Z,

429
00:19:54,530 --> 00:19:57,060
ou, se x mais z é menos
que ou igual a Y,

430
00:19:57,060 --> 00:20:01,730
ou, se y mais z é menor do que ou igual a
X, que também não pode ser um triângulo válido.

431
00:20:01,730 --> 00:20:03,800
Então, nós return false novamente.

432
00:20:03,800 --> 00:20:06,900
Supondo que nós passamos tanto dos controlos
embora, então podemos retornar true.

433
00:20:06,900 --> 00:20:09,440
Porque esses três lados
são capazes de returning--

434
00:20:09,440 --> 00:20:11,647
de criar um triângulo válido.

435
00:20:11,647 --> 00:20:12,230
E é isso.

436
00:20:12,230 --> 00:20:13,830
Você já declarada e definida.

437
00:20:13,830 --> 00:20:17,330
E você pode ser capaz de agora
usar e chamar essa função.

438
00:20:17,330 --> 00:20:19,470
Bom trabalho.

439
00:20:19,470 --> 00:20:20,650
Eu sou Doug Lloyd.

440
00:20:20,650 --> 00:20:22,820
Este é CS50.

441
00:20:22,820 --> 00:20:24,340