1
00:00:00,000 --> 00:00:00,160

2
00:00:00,160 --> 00:00:04,010
>> COLUNA 1: Então, eu sinto que tendem a
escrever printf Olá mundo ou printf

3
00:00:04,010 --> 00:00:08,160
Olá por cento s, muitas vezes em contextos
onde eu quero imprimir uma

4
00:00:08,160 --> 00:00:11,360
corda, por vezes, pedindo a
parte do usuário do que string.

5
00:00:11,360 --> 00:00:14,980
Bem, não seria bom se nós criamos
uma função do nosso próprio chamado,

6
00:00:14,980 --> 00:00:19,900
dizer, o nome de impressão, cujo propósito na vida
é simplesmente para imprimir Olá vírgula

7
00:00:19,900 --> 00:00:24,560
assim e assim, ao aceitar o tal e tão
como um argumento para essa função?

8
00:00:24,560 --> 00:00:29,220
Podemos declarar uma função do nosso próprio
Assim como podemos em Scratch como segue.

9
00:00:29,220 --> 00:00:35,280
>> Em outras palavras, suponha que eu gostaria de
printf o seu nome e, em seguida, pedir que o usuário

10
00:00:35,280 --> 00:00:39,470
para o seu nome com corda
s é igual GetString.

11
00:00:39,470 --> 00:00:42,060
E então eu quero chamar uma função
chamou o nome de impressão

12
00:00:42,060 --> 00:00:44,340
passar um s como sua entrada.

13
00:00:44,340 --> 00:00:47,770
>> Agora, infelizmente, não há nenhuma função
chamou o nome de impressão em C ou em

14
00:00:47,770 --> 00:00:48,950
a biblioteca de CS50.

15
00:00:48,950 --> 00:00:51,220
Mas não importa, porque nós
pode fazê-lo nós mesmos.

16
00:00:51,220 --> 00:00:54,560
Para declarar uma função do nosso próprio e
em seguida, implementá-lo, podemos simplesmente fazer

17
00:00:54,560 --> 00:00:59,000
algum espaço neste arquivo e declarar
esta função da seguinte forma, nula -

18
00:00:59,000 --> 00:01:01,900
o que significa que a função não é
realmente vai devolver alguma coisa,

19
00:01:01,900 --> 00:01:03,890
embora terá
um efeito colateral -

20
00:01:03,890 --> 00:01:08,030
imprimir o nome, e em seguida, vamos especificar em
parênteses que o nome de impressão espera um

21
00:01:08,030 --> 00:01:09,680
argumento do tipo string.

22
00:01:09,680 --> 00:01:12,180
E, em geral, vamos pensar
do que como um nome.

23
00:01:12,180 --> 00:01:15,140
>> E vamos abrir a nossa cinta
e fechar a nossa cinta.

24
00:01:15,140 --> 00:01:21,930
E então printf dentro Olá vírgula
novo nome da linha de vírgula por cento s.

25
00:01:21,930 --> 00:01:24,570
Em outras palavras, mesmo que isso
função é apenas uma linha de código,

26
00:01:24,570 --> 00:01:27,290
que agora tem algum superior
propósito nível para impressão

27
00:01:27,290 --> 00:01:28,950
o nome de alguém com uma saudação.

28
00:01:28,950 --> 00:01:33,115
>> Agora dentro do principal, perceber que eu sou
chamando o nome de impressão por meio de um s.

29
00:01:33,115 --> 00:01:35,830
E assim me parece agora ter
um programa completo.

30
00:01:35,830 --> 00:01:38,650
A única diferença é a partir de outros
nós escrevemos é que não só faz

31
00:01:38,650 --> 00:01:42,480
este programa tem principal, ele também tem um
declaração e implementação de

32
00:01:42,480 --> 00:01:44,740
Nome de impressão, em função do meu próprio.

33
00:01:44,740 --> 00:01:49,505
>> Vamos agora compilar o meu programa com o make
função zero, e executá-lo com um ponto

34
00:01:49,505 --> 00:01:51,080
reduzir a função zero.

35
00:01:51,080 --> 00:01:53,390
Quando solicitado para o meu nome
Vou digitar David.

36
00:01:53,390 --> 00:01:55,830
E eu realmente sou cumprimentado
com "Olá, David."

37
00:01:55,830 --> 00:02:00,160
>> Agora, não é que eu deliberadamente
declarou o nome de impressão acima principal,

38
00:02:00,160 --> 00:02:03,860
dizendo assim C de antemão que não
existe uma função chamada de impressão

39
00:02:03,860 --> 00:02:06,930
nome para que eu pudesse usar
que mais tarde, em principal.

40
00:02:06,930 --> 00:02:11,610
Agora, se eu colocar o nome em vez de impressão em
Do fundo do meu arquivo, pois, sinceramente, eu

41
00:02:11,610 --> 00:02:15,310
provavelmente deve fazer para que os principais restos
a primeira coisa que eu ou

42
00:02:15,310 --> 00:02:18,450
outro usuário vê no meu código,
verifica-se que o meu código é

43
00:02:18,450 --> 00:02:19,780
não vai compilar.

44
00:02:19,780 --> 00:02:23,610
>> Especificamente, se eu voltar para o meu
janela de terminal e executar fazer a função

45
00:02:23,610 --> 00:02:26,120
zero, agora, perceber que eu estou gritou.

46
00:02:26,120 --> 00:02:30,340
Se eu rolar para cima em minha janela de terminal,
Eu vou ver este primeiro erro em vermelho,

47
00:02:30,340 --> 00:02:33,120
declaração implícita de
função nome de impressão.

48
00:02:33,120 --> 00:02:34,220
>> Agora, o que isso significa?

49
00:02:34,220 --> 00:02:37,190
Bem, mesmo que eu tenha implementado
imprimir o nome deste arquivo, eu não tenho

50
00:02:37,190 --> 00:02:40,080
implementada antes que eu tenho
usou em principal.

51
00:02:40,080 --> 00:02:43,160
Agora, nós poderíamos voltar para o velho
versão e nome de impressão colocar de

52
00:02:43,160 --> 00:02:44,450
implementação em cima.

53
00:02:44,450 --> 00:02:48,730
>> Mas posso ao invés de apenas dar uma dica C
que não há uma função para vir.

54
00:02:48,730 --> 00:02:55,390
Especificamente, acima principal posso declarar
imprimir o nome assim como fiz anteriormente, mas

55
00:02:55,390 --> 00:02:59,450
terminar a linha com um ponto e vírgula, assim
prometendo implementar, mas ainda não

56
00:02:59,450 --> 00:03:02,180
realmente implementar a função
chamou o nome de impressão.

57
00:03:02,180 --> 00:03:05,860
Posso, então, tem principal no topo da minha
arquivo como eu esperava, e eu posso realmente

58
00:03:05,860 --> 00:03:07,440
implementar nome impresso na parte inferior.

59
00:03:07,440 --> 00:03:12,860
>> Se eu agora voltar para a minha janela de terminal
e recompilar função a zero com o make,

60
00:03:12,860 --> 00:03:14,390
desta vez ele compila.

61
00:03:14,390 --> 00:03:18,240
E se eu executá-lo com a função de corte de ponto
zero, proporcionando o meu nome, eu estou

62
00:03:18,240 --> 00:03:20,650
saudado como "Olá, David."

63
00:03:20,650 --> 00:03:22,268