1
00:00:07,150 --> 00:00:08,850
[Powered by Google Translate] DAVID DICIURCIO: Então, um conceito importante para compreender em

2
00:00:08,850 --> 00:00:11,010
programação é a noção de escopo.

3
00:00:11,010 --> 00:00:13,860
Âmbito pode ser definida como o contexto em que a variável é

4
00:00:13,860 --> 00:00:15,610
visível ou acessível.

5
00:00:15,610 --> 00:00:18,150
Por exemplo, vamos dizer que temos uma função, principal, que é

6
00:00:18,150 --> 00:00:22,570
suposto que incrementa uma variável, x, 1-2.

7
00:00:22,570 --> 00:00:25,690
Como podemos ver, a principal inicializa x para um, imprime

8
00:00:25,690 --> 00:00:28,740
algum texto, em seguida, executa o incremento da função, antes de

9
00:00:28,740 --> 00:00:30,540
imprimindo mais texto.

10
00:00:30,540 --> 00:00:32,545
Se esta função fosse para funcionar corretamente, seria

11
00:00:32,545 --> 00:00:34,120
imprimir x como 2.

12
00:00:34,120 --> 00:00:35,370
Vamos tentar.

13
00:00:38,870 --> 00:00:43,075
>> Então, como você pode ver, o principal não faz o que esperávamos.

14
00:00:43,075 --> 00:00:45,310
Ele devolve o valor 1, em vez

15
00:00:45,310 --> 00:00:47,150
do que o 2 esperávamos.

16
00:00:47,150 --> 00:00:50,060
A razão para este erro pode ser explicado pelo escopo.

17
00:00:50,060 --> 00:00:52,185
Na função, principal, inicializado x

18
00:00:52,185 --> 00:00:53,820
apenas dentro da função.

19
00:00:53,820 --> 00:00:56,580
Em outras palavras, a variável x é declarada localmente dentro do

20
00:00:56,580 --> 00:00:58,640
função, principal, e não é acessível

21
00:00:58,640 --> 00:01:00,210
fora da função.

22
00:01:00,210 --> 00:01:03,580
Apenas principal pode aceder x nesta situação.

23
00:01:03,580 --> 00:01:06,990
Quando chamamos incremento nós não passamos x como entrada, mas

24
00:01:06,990 --> 00:01:08,960
apenas uma cópia de x.

25
00:01:08,960 --> 00:01:11,640
Como resultado disto, o incremento da função apenas adiciona

26
00:01:11,640 --> 00:01:14,190
o valor de 1 para uma cópia do valor de x.

27
00:01:14,190 --> 00:01:16,170
Mas não para o próprio x.

28
00:01:16,170 --> 00:01:19,090
Quando voltar a principal, x em si não mudou em nada.

29
00:01:19,090 --> 00:01:22,370
Assim imprimir x só vai produzir o valor de 1.

30
00:01:22,370 --> 00:01:24,890
>> Bem, então, que deixa a questão: como devemos corrigir

31
00:01:24,890 --> 00:01:26,230
esta função?

32
00:01:26,230 --> 00:01:29,500
Uma solução é ter incremento de retornar um valor.

33
00:01:29,500 --> 00:01:31,180
Deste modo, o incremento da função vai

34
00:01:31,180 --> 00:01:33,350
nos devolver um inteiro.

35
00:01:33,350 --> 00:01:35,420
Então, aqui está o nosso código revisto com a

36
00:01:35,420 --> 00:01:37,480
função de incremento alternativo.

37
00:01:37,480 --> 00:01:41,510
Aqui, em vez voltou a x + 1, em vez de apenas o fim

38
00:01:41,510 --> 00:01:44,070
com x igual a x + 1.

39
00:01:44,070 --> 00:01:46,290
Além disso, tomar conhecimento de que nós substituímos a saída de

40
00:01:46,290 --> 00:01:49,630
incremento, anteriormente anular, com int, afirmando que

41
00:01:49,630 --> 00:01:52,230
incremento vai agora passar de volta um valor inteiro.

42
00:01:52,230 --> 00:01:55,000
Agora, depois de corridas de incremento, ele irá retornar com um valor de

43
00:01:55,000 --> 00:01:56,535
2, exatamente como pretendia.

44
00:01:59,630 --> 00:02:02,260
>> Outra situação que demonstra importância âmbito do

45
00:02:02,260 --> 00:02:04,860
é em scopeloop.c.

46
00:02:04,860 --> 00:02:07,320
Neste código, temos um loop em que a variável

47
00:02:07,320 --> 00:02:10,310
total é inicializado durante cada passo.

48
00:02:10,310 --> 00:02:13,720
Infelizmente, este código não compila.

49
00:02:13,720 --> 00:02:16,690
Isto é porque o total variável na verdade não existe

50
00:02:16,690 --> 00:02:18,550
fora do loop.

51
00:02:18,550 --> 00:02:21,000
Variáveis ​​declaradas dentro de loops só existe dentro do

52
00:02:21,000 --> 00:02:23,967
laço propriamente dito e é demonstrada no nosso erro

53
00:02:23,967 --> 00:02:25,880
total de mensagem, não declarados.

54
00:02:25,880 --> 00:02:28,710
O total variável tem ainda de ser declaradas no âmbito

55
00:02:28,710 --> 00:02:30,420
da função principal.

56
00:02:30,420 --> 00:02:33,610
Além disso, durante cada iteração do loop for nosso, nós

57
00:02:33,610 --> 00:02:36,340
são reinitializing nosso total a 0.

58
00:02:36,340 --> 00:02:39,210
Isso por si só não manter o código de compilação, mas

59
00:02:39,210 --> 00:02:42,920
impediria total de já soma a um valor passado 1.

60
00:02:42,920 --> 00:02:45,760
>> Mais uma vez, qual é a melhor maneira de corrigir isso?

61
00:02:45,760 --> 00:02:48,520
Um dos métodos mais fáceis inclui fazer local total de

62
00:02:48,520 --> 00:02:51,990
a função principal, em vez de para a própria espira.

63
00:02:51,990 --> 00:02:55,210
Isto irá total para realmente aumentar, e, finalmente,

64
00:02:55,210 --> 00:02:57,880
permitir que ele seja impresso após o loop.

65
00:02:57,880 --> 00:03:00,093
Outra técnica que eu só vou resumir faria

66
00:03:00,093 --> 00:03:02,190
ser o uso de variáveis ​​globais.

67
00:03:02,190 --> 00:03:04,890
As variáveis ​​globais são variáveis ​​que são declaradas antes de main

68
00:03:04,890 --> 00:03:07,860
que manter o seu valor ao longo de todo o programa.

69
00:03:07,860 --> 00:03:10,710
É claro que as funções podem alterar o valor de um global,

70
00:03:10,710 --> 00:03:13,470
mas eles não saem do escopo como variáveis ​​locais.

71
00:03:13,470 --> 00:03:15,880
No entanto, o uso de variáveis ​​globais tende a ser careta

72
00:03:15,880 --> 00:03:18,180
sobre como o design ruim, uma vez que existem maneiras melhores de

73
00:03:18,180 --> 00:03:20,080
compartilhamento de dados entre as funções.

74
00:03:20,080 --> 00:03:21,920
Por exemplo, o uso de ponteiros.

75
00:03:21,920 --> 00:03:24,250
Mas mais sobre isso em outro momento.

76
00:03:24,250 --> 00:03:26,670
>> Finalmente, é importante ter uma compreensão do escopo

77
00:03:26,670 --> 00:03:29,550
no contexto da memória do computador, ou RAM.

78
00:03:29,550 --> 00:03:32,470
Quando executar um programa, as variáveis ​​locais e funções

79
00:03:32,470 --> 00:03:34,040
são adicionados a um local específico no

80
00:03:34,040 --> 00:03:36,010
RAM chamado a pilha.

81
00:03:36,010 --> 00:03:39,230
Como retorno funções, os quadros de pilha das variáveis ​​são

82
00:03:39,230 --> 00:03:43,910
eficazmente removido da pilha liberando mais memória.

83
00:03:43,910 --> 00:03:46,750
Assim, ao analisar o escopo, certifique-se lembrar estes três

84
00:03:46,750 --> 00:03:47,980
pontos-chave.

85
00:03:47,980 --> 00:03:51,220
Um escopo, pode ser local ou global.

86
00:03:51,220 --> 00:03:53,990
Depende de onde a variável é declarada.

87
00:03:53,990 --> 00:03:57,040
Duas variáveis ​​declaradas, ou inicializado em funções são

88
00:03:57,040 --> 00:03:59,510
local para a função e não pode ser alterada por outra

89
00:03:59,510 --> 00:04:02,790
funções, pelo menos não sem o uso de ponteiros.

90
00:04:02,790 --> 00:04:05,340
Finalmente, as variáveis ​​são sempre locais de laçadas que são

91
00:04:05,340 --> 00:04:06,490
declarado dentro.

92
00:04:06,490 --> 00:04:08,100
As variáveis ​​não são acessíveis

93
00:04:08,100 --> 00:04:09,860
fora do circuito.

94
00:04:09,860 --> 00:04:11,170
>> Isso é tudo para agora escopo.

95
00:04:11,170 --> 00:04:12,420
Obrigado por assistir.