1
00:00:04,350 --> 00:00:05,430
‫Olá e bem-vindo.

2
00:00:05,430 --> 00:00:12,630
‫Nesta palestra, vamos aprender como podemos obter um ponteiro para o ato de propriedade de um componente.

3
00:00:12,840 --> 00:00:16,680
‫Vamos descobrir o que é um ponteiro, quais endereços estão na memória,

4
00:00:16,680 --> 00:00:19,560
‫e vamos imprimi-los em nossas mensagens de log também.

5
00:00:19,710 --> 00:00:20,370
‫Vamos mergulhar.

6
00:00:21,150 --> 00:00:27,570
‫Então, vamos tomar um segundo para entender um conceito central do que está acontecendo na programação em geral

7
00:00:27,570 --> 00:00:29,100
‫sobre endereços de variáveis.

8
00:00:29,100 --> 00:00:30,750
‫O que é um endereço de uma variável?

9
00:00:30,750 --> 00:00:41,280
‫Bem, nós armazenamos todas as nossas variáveis na memória em que há chips de memória RAM em seu computador e variáveis requerem

10
00:00:41,280 --> 00:00:43,890
‫memória para armazenar seus dados.

11
00:00:43,890 --> 00:00:51,790
‫Portanto, um número de ponto flutuante requer 32 bits de dados ou 64, se for um número inteiro duplo, requer uma certa quantidade

12
00:00:51,790 --> 00:00:52,680
‫de memória.

13
00:00:52,680 --> 00:00:58,080
‫Além disso, quanto maiores as estruturas que você possui ou maiores as classes que você possui, como

14
00:00:58,080 --> 00:01:03,600
‫atores podem ser muito grandes e abranger muitos dados podem exigir até alguns kilobytes de memória por ator, coisas

15
00:01:03,600 --> 00:01:03,960
‫assim.

16
00:01:04,620 --> 00:01:12,270
‫Bem, essa memória tem que viver em algum lugar nesse grande campo de dados vazios que são seus bancos de memória.

17
00:01:12,750 --> 00:01:16,290
‫E esse local é conhecido como endereço.

18
00:01:16,440 --> 00:01:18,180
‫Então, como isso funciona na prática?

19
00:01:18,540 --> 00:01:21,840
‫Bem, imagine que temos esse grande campo de zeros e uns.

20
00:01:21,840 --> 00:01:24,900
‫Esses são os dados da sua ram.

21
00:01:25,410 --> 00:01:32,550
‫Bom, então a variável, uma variável de ator chamada meu ator precisa ter uma certa localização dentro dessa

22
00:01:32,550 --> 00:01:36,900
‫memória que é alocada para armazenar os dados no ator.

23
00:01:37,260 --> 00:01:42,030
‫Portanto, essa seção vermelha da memória pode ser onde estamos armazenando os

24
00:01:42,420 --> 00:01:50,580
‫dados para esse ator em particular, e tem um endereço geralmente indicado em binário ou hexadecimal que é essencialmente apenas o local.

25
00:01:50,580 --> 00:01:57,780
‫Se você começar a contar todos os bytes, todos os uns e zeros aqui, na verdade, nós não contamos os zeros

26
00:01:57,780 --> 00:01:59,160
‫e uns individuais.

27
00:01:59,160 --> 00:02:03,300
‫Contamos em passos de oito, mas isso não é muito importante.

28
00:02:03,300 --> 00:02:04,170
‫Contamos os bytes.

29
00:02:04,680 --> 00:02:07,770
‫Esse é essencialmente o endereço por onde começamos.

30
00:02:08,780 --> 00:02:10,880
‫Falando sobre nosso ator.

31
00:02:11,090 --> 00:02:14,150
‫E então cada tipo tem um certo tamanho.

32
00:02:14,150 --> 00:02:17,960
‫Portanto, sabemos que o ator exigiria tantos bytes de dados.

33
00:02:17,960 --> 00:02:22,940
‫E isso nos diz onde encontrar os dados sobre nosso ator em particular.

34
00:02:23,450 --> 00:02:24,830
‫Então, por que isto é importante?

35
00:02:24,860 --> 00:02:29,360
‫Bem, vamos dar uma olhada na situação em que podemos querer fazer uma tomada.

36
00:02:29,720 --> 00:02:30,650
‫Dois atores.

37
00:02:30,650 --> 00:02:34,070
‫Temos apenas duas variáveis que referenciam os mesmos dados.

38
00:02:34,640 --> 00:02:38,200
‫Bem, no caso ingênuo, simplesmente copiamos isso.

39
00:02:38,200 --> 00:02:46,820
‫Portanto, temos um pedaço de memória que é alocado para a variável meu ator por outro pedaço de memória que está alocado

40
00:02:46,820 --> 00:02:52,040
‫para uma variável vazia chamada seu ator, à qual ainda não atribuímos nada.

41
00:02:52,640 --> 00:02:59,000
‫E então o que queremos fazer porque queremos que eles contenham os mesmos dados, é apenas atribuir um ao

42
00:02:59,000 --> 00:02:59,450
‫outro.

43
00:02:59,720 --> 00:03:07,010
‫E isso essencialmente resulta em apenas fazer uma cópia de todos os bits de dados que estavam no meu ator e colocá-los

44
00:03:07,010 --> 00:03:10,190
‫em todos os bits que compõem o seu ator.

45
00:03:10,820 --> 00:03:17,930
‫Portanto, esse pode ser um procedimento bastante caro porque sua CPU precisa avaliar cada pedaço de memória

46
00:03:17,930 --> 00:03:22,550
‫no original e colocá-lo no novo local, o que leva tempo.

47
00:03:22,670 --> 00:03:25,750
‫Agora há uma maneira de contornar isso usando algo chamado ponteiro.

48
00:03:25,760 --> 00:03:33,470
‫Então aqui, em vez de armazenar a totalidade do Meu Ator, temos uma variável chamada meu ator ou

49
00:03:33,470 --> 00:03:38,770
‫um ator um ponteiro de ator que não armazena o ator inteiro.

50
00:03:38,780 --> 00:03:42,100
‫Ele apenas armazena o endereço onde você pode encontrar um ato.

51
00:03:42,110 --> 00:03:46,520
‫Então você pode ver que realmente usa muito menos memória para armazenar um endereço.

52
00:03:46,520 --> 00:03:53,930
‫E então o que fazemos é no seu ator, armazenamos o endereço do meu ator, então ele acaba apontando para o

53
00:03:54,260 --> 00:03:58,880
‫ator original em vez de copiar os dados, daí o ponteiro do nome.

54
00:03:59,360 --> 00:04:01,820
‫Agora esta não é a sintaxe real em C++.

55
00:04:01,820 --> 00:04:04,130
‫Em C++, a sintaxe é muito mais condensada.

56
00:04:04,640 --> 00:04:09,610
‫Dizemos que algo é um ponteiro colocando uma estrela após o tipo.

57
00:04:09,620 --> 00:04:17,930
‫Portanto, uma estrela de ator significa que este é um ponteiro de ator e para obter o endereço de uma variável, usamos um e

58
00:04:17,930 --> 00:04:19,670
‫comercial que não usaremos.

59
00:04:19,670 --> 00:04:24,680
‫Faça muito uso deste endereço ainda porque há muitas funções no irreal que retornam

60
00:04:24,680 --> 00:04:25,190
‫ponteiros.

61
00:04:25,190 --> 00:04:30,860
‫Então, só precisamos saber como usar esses pontos em vez de criá-los por enquanto.

62
00:04:31,730 --> 00:04:40,060
‫Então, uma dessas funções que nos permite ter acesso a outros objetos em nossa cena é get ona.

63
00:04:40,070 --> 00:04:46,310
‫Então, por que isso se aplica quando temos um componente que pertence a um ator?

64
00:04:46,490 --> 00:04:53,600
‫Então, se quisermos que esse componente converse com nosso ator, obtenha sua localização, defina sua localização e faça

65
00:04:53,600 --> 00:04:58,370
‫coisas assim, precisamos ser capazes de obter um ponteiro para esse ator.

66
00:04:58,370 --> 00:04:59,780
‫Não queremos fazer uma cópia dele.

67
00:05:00,020 --> 00:05:03,290
‫Na verdade, não queremos copiar porque queremos mudar o ator.

68
00:05:03,290 --> 00:05:06,950
‫Se estivermos fazendo uma alteração em uma cópia, ela não aparecerá na cena.

69
00:05:07,430 --> 00:05:13,640
‫Portanto, precisamos ser capazes de armazenar uma variável que seja um ponteiro para um ator.

70
00:05:14,330 --> 00:05:19,580
‫A maneira como fazemos isso, como acabamos de ver nos slides, é ter um tipo de ator.

71
00:05:19,760 --> 00:05:25,940
‫Mas então colocamos uma estrela no final que nos diz que este não é um ator sendo armazenado aqui, este é

72
00:05:25,940 --> 00:05:28,670
‫apenas o endereço de um ator sendo armazenado.

73
00:05:29,240 --> 00:05:36,530
‫Então, pegamos o ator e vamos chamar esse proprietário, e então vamos definir isso igual ao

74
00:05:36,530 --> 00:05:39,080
‫resultado de chamar get proprietário.

75
00:05:39,080 --> 00:05:47,010
‫Então, get owner é uma função de um componente de ator que permite que você obtenha um ponteiro de proprietário, obtenha um

76
00:05:47,030 --> 00:05:53,480
‫ponteiro de ator que aponte para o proprietário, coloque um ponto e vírgula no final dessa linha.

77
00:05:53,720 --> 00:06:00,740
‫E o que temos aqui é uma variável que armazena o endereço de um ator que possui esse componente

78
00:06:00,740 --> 00:06:01,400
‫específico.

79
00:06:01,760 --> 00:06:07,550
‫Então eu gostaria de desafiá-lo a fazer algo imprimindo o endereço desta variável.

80
00:06:07,550 --> 00:06:12,530
‫Portanto, use a variável ator e use a porcentagem que você formata.

81
00:06:12,590 --> 00:06:14,690
‫Especifique o fim dos logs.

82
00:06:14,690 --> 00:06:19,490
‫Então por cento significa essencialmente que você está usando um inteiro sem sinal.

83
00:06:19,490 --> 00:06:24,980
‫Isso significa um inteiro que não pode ser negativo, o que faz sentido porque os endereços não podem ser

84
00:06:25,790 --> 00:06:32,060
‫negativos quando estamos falando sobre onde encontrar memória e depois descobrir o que ela imprime, vá jogar, veja a mensagem de log,

85
00:06:32,060 --> 00:06:33,710
‫veja o que ele imprime.

86
00:06:34,190 --> 00:06:37,760
‫Ele muda entre diferentes jogadas se você parar de jogar e começar a jogar novamente?

87
00:06:38,090 --> 00:06:41,720
‫E se o filme for sobre vários atores?

88
00:06:41,900 --> 00:06:45,650
‫Existem vários endereços diferentes impressos no console?

89
00:06:45,650 --> 00:06:48,380
‫Pause o vídeo e faça uma pequena investigação.

90
00:06:51,940 --> 00:06:52,360
‫OK.

91
00:06:52,360 --> 00:06:53,050
‫Bem vindo de volta.

92
00:06:53,500 --> 00:07:03,370
‫Então vamos para este outro log e vamos dizer mudança, endereço próprio, dois pontos percentuais.

93
00:07:03,400 --> 00:07:07,270
‫Você sabe, é aí que vai colocar o ponto de valor.

94
00:07:07,990 --> 00:07:10,150
‫E então vamos colocar o ponteiro real.

95
00:07:10,150 --> 00:07:12,160
‫Então vamos ter o dono aqui.

96
00:07:12,940 --> 00:07:16,120
‫Então ele vai imprimir o endereço do proprietário.

97
00:07:16,540 --> 00:07:18,970
‫Vamos para o irreal.

98
00:07:19,180 --> 00:07:21,670
‫Controle de hits alt f 11.

99
00:07:21,940 --> 00:07:24,550
‫E quando isso terminar de compilar, vamos apertar o play.

100
00:07:24,550 --> 00:07:29,680
‫E o que estamos vendo é que a mensagem de log que move o endereço do proprietário está chegando e está nos

101
00:07:29,680 --> 00:07:32,050
‫dando um número muito grande, na verdade, para esse endereço.

102
00:07:32,440 --> 00:07:36,250
‫E se eu parar de jogar e jogar novamente só por um segundo?

103
00:07:36,490 --> 00:07:42,700
‫Você pode ver que o endereço é substancialmente diferente e isso porque toda vez que

104
00:07:43,180 --> 00:07:51,250
‫apertamos o play, a Unreal está criando um novo conjunto de atores na cena, basicamente prontos para jogar, começando do

105
00:07:51,250 --> 00:07:51,810
‫zero.

106
00:07:51,820 --> 00:07:57,160
‫Então é por isso que estamos vendo novos endereços cada vez que apertamos o play.

107
00:07:57,190 --> 00:08:04,900
‫O que acontece se eu for para este pilar, por exemplo, e adicionar um movimento, um componente ao pilar também, e nós apertarmos o play

108
00:08:04,900 --> 00:08:07,990
‫e rolarmos para baixo até o final dos meus logs.

109
00:08:07,990 --> 00:08:15,220
‫Você pode ver que há cada tick dois endereços diferentes sendo impressos aqui porque há dois

110
00:08:15,220 --> 00:08:20,680
‫atores diferentes que são armazenados em dois locais diferentes na memória.

111
00:08:21,010 --> 00:08:25,930
‫Então, esses são os dois endereços e você pode ver que na verdade

112
00:08:25,930 --> 00:08:31,660
‫há alguns megabytes de diferença entre esses dois endereços, o que apenas diz quanta informação está sendo

113
00:08:31,870 --> 00:08:38,040
‫armazenada na memória pelo Unreal e também por que é importante ser eficiente em não fazer muitas cópias.

114
00:08:38,350 --> 00:08:39,490
‫Isso é tudo para esta palestra.

115
00:08:39,760 --> 00:08:40,840
‫Eu vou te ver entrar.

116
00:08:40,840 --> 00:08:43,330
‫O próximo será fazer coisas mais divertidas com ponteiros.