‫Então sabemos que precisamos de alguns componentes em nossa base -- class.
‫Sabemos que precisamos de uma malha de base para a parte inferior do tanque e a torre.
‫Também precisamos de uma malha de torre para a parte superior.
‫Precisamos de uma cápsula para lidar com a colisão e precisamos de um ponto de geração de projéteis.
‫Isso vai ser um componente de cena.
‫Agora, uma vez que adicionamos essas coisas à classe base do pod, qualquer coisa que criarmos com
‫base nessa classe herdará essas coisas.
‫Então poderíamos criar um tanque baseado na base -- e então poderíamos ir e criar uma torre também baseada na base
‫--.
‫E como eles são baseados no pod base, eles herdam esses componentes.
‫O tanque pode ter sua própria malha de base, sua própria malha de torre, sua própria cápsula e seu próprio ponto de geração de
‫projéteis.
‫E da mesma forma, a torre terá seu próprio componente de cápsula de malha de torre de malha de base e ponto de desova
‫de projéteis também.
‫E veremos muito em breve como podemos atribuir diferentes malhas a cada uma delas para que pareçam diferentes.
‫Então sabemos que precisamos de alguns componentes.
‫Agora é hora de realmente adicionar alguns componentes à nossa base -- class.
‫Agora, por padrão, já temos uma seção pública, uma seção protegida e a segunda seção pública
‫aqui embaixo.
‫Existem vários motivos para ter várias seções públicas e falaremos sobre isso mais tarde.
‫Mas para nossos componentes, vamos criar uma seção privada.
‫Como você aprendeu anteriormente, é bom que as variáveis de membro sejam privadas, para que sejam acessíveis
‫apenas de dentro da classe que as possui.
‫Então, precisamos de alguns componentes.
‫O primeiro que vou adicionar é a cápsula.
‫Então vamos criar uma variável do tipo seu componente cápsula.
‫Agora isso vai ser um ponteiro.
‫Vamos usar ponteiros para a maioria de nossas variáveis, desde que não sejam tipos base
‫como integer ou float.
‫E como você sabe, é porque os ponteiros são leves, são apenas endereços e nos permitem
‫ser mais eficientes.
‫Portanto, temos esse ponteiro de componente de cápsula U e vamos chamar essa composição de cápsula abreviada de componente de
‫cápsula.
‫Agora, logo acima do componente de cápsula, vamos adicionar uma macro específica do mecanismo irreal e sua propriedade em
‫letras maiúsculas com seus próprios parênteses.
‫Sua propriedade é uma maneira de tornar o mecanismo irreal ciente dessa variável para que ele possa participar de mecanismos
‫irreais.
‫Sistema de Reflexão.
‫O sistema de reflexão nos permite fazer coisas como expor essa variável a blueprints e participar da
‫coleta de lixo e coisas assim.
‫Portanto, adicionar a propriedade you será algo que adicionará aos nossos componentes à medida que os criamos.
‫Portanto, temos esse componente de cápsula e, como estamos usando o tipo de componente de cápsula
‫YOU, precisamos informar o compilador sobre esse tipo.
‫Ele não sabe por padrão o que é um componente de cápsula.
‫Agora, normalmente, para dizer ao compilador o que é um componente de cápsula, incluiríamos um arquivo de cabeçalho aqui no
‫topo com nossas diretivas de inclusão se formos para a documentação do mecanismo irreal e
‫procurarmos seu componente de cápsula, podemos ver aqui onde diz inclua o arquivo de cabeçalho que precisaríamos
‫incluir para informar ao compilador sobre o componente da cápsula.
‫Agora podemos incluir isso aqui no topo e depois nosso U.
‫O tipo de componente da cápsula seria reconhecido pelo compilador e tudo seria ótimo.
‫Mas, em geral, uma boa prática quando se trata de codificar essas coisas é tentar manter esse arquivo
‫de cabeçalho o menor possível.
‫Sempre que incluímos um arquivo de cabeçalho nesse arquivo, um programa chamado pré-processador pega todo o conteúdo desse
‫arquivo de cabeçalho, retira algumas coisas como comentários e, em seguida, cola literalmente todo
‫o conteúdo desse arquivo de cabeçalho nesse arquivo.
‫O resultado é que este arquivo fica maior porque tem o conteúdo desse arquivo incluído e
‫cole-o aqui.
‫Nós só queremos incluir coisas quando as usamos.
‫Então, como podemos nos livrar de não incluir o arquivo de cabeçalho aqui na base -- header?
‫Bem, podemos usar algo em C++ conhecido como declaração de encaminhamento.
‫Declaramos esse tipo de componente de cápsula u usando a palavra-chave class assim.
‫Observe que o compilador agora mostra esse tipo como verde sempre que enviamos a declaração de uma variável e conseguimos evitar
‫a inclusão de seu arquivo de cabeçalho.
‫Ele está dizendo ao compilador que este é um tipo, então ele não nos dará mais erros do IntelliSense, dizendo
‫que ele não reconhece isso como um tipo.
‫Agora este é um tipo incompleto.
‫Se realmente tentarmos usar esse tipo acessando membros como funções e variáveis ou tentando construir um
‫objeto desse tipo, obteremos um erro porque é um tipo incompleto.
‫Precisaríamos do arquivo de cabeçalho incluído sempre que usarmos esse tipo para fazer essas coisas, para que pudéssemos declarar um ponteiro
‫de um tipo para evitar a necessidade do arquivo de cabeçalho.
‫Mas é importante observar que precisamos de arquivos de cabeçalho para herdar de classes específicas.
‫Observe que esta classe herda de uma lagoa e o arquivo de cabeçalho da lagoa está incluído aqui no topo.
‫Portanto, a herança requer o arquivo de cabeçalho para o tipo do qual estamos herdando.
‫Então, vamos discutir a declaração antecipada e por que queremos fazê-la.
‫Digamos que temos uma classe chamada Base Pon que precisa ter uma variável de ponteiro do tipo seu componente
‫de cápsula.
‫Agora seu componente de cápsula está no arquivo de cabeçalho do componente de cápsula.
‫Agora, na verdade, vamos usar esse tipo com base em quando construímos um objeto do U.
‫Tipo de componente da cápsula.
‫Então, com base em tudo o que realmente precisamos é ter um ponteiro do componente cápsula do tipo U.
‫Agora, a verdade é baseada em H, na verdade, não precisa dos detalhes de implementação da classe de componentes da
‫cápsula.
‫Em outras palavras, ele não precisa saber como as funções são definidas ou mesmo quão grande é a classe do
‫componente da cápsula.
‫Um ponteiro de componente de cápsula é do mesmo tamanho que qualquer outro ponteiro.
‫É apenas um endereço.
‫Agora na classe do plano base.
‫Queremos construir o componente cápsula.
‫Por esse motivo, precisamos saber o tamanho de um componente de cápsula para dispor a memória necessária para
‫criar esse objeto.
‫Portanto, enquanto o cabeçalho do componente da cápsula não é estritamente necessário na base Ponca, é absolutamente necessário na base.
‫Porkpie Então, uma boa prática de programação é incluir apenas cabeçalhos onde você realmente precisa deles para que possamos declarar um ponteiro
‫do tipo U ponteiro de componente de cápsula no produto base H e, em seguida, incluir componentes de cápsula
‫onde precisamos dos detalhes de implementação porque estamos construindo um componente de cápsula e precisamos saber o
‫tamanho de a.
‫Componente de cápsula na memória.
‫Agora vamos discutir as consequências de incluir o arquivo de cabeçalho no base pond FX.
‫Como vimos, podemos absolutamente fazer isso e você pode estar pensando, bem, estamos incluindo isso
‫na base pont CP De qualquer forma, que diferença faz se incluí-lo em um arquivo versus outro?
‫Agora é aqui que entra o problema.
‫Os arquivos de cabeçalho são projetados para serem incluídos por outros arquivos.
‫Então, digamos que temos o Base Pond H e incluímos componentes de cápsula nele.
‫E, mais adiante, temos outra classe e teremos um ponteiro de base pond em alguma outra
‫classe, assim como tínhamos um ponteiro de componente de cápsula no pod base.
‫Agora, ao invés de passar pelo problema de declarar o ponteiro base do lago
‫e alguma outra classe, vamos apenas declará-lo como normal e incluir o peão base em alguma outra classe.
‫Portanto, agora o Base Pond H não inclui apenas o cabeçalho do componente da cápsula, o que resulta em mais código sendo copiado
‫para esse arquivo de cabeçalho.
‫Agora, alguma outra classe tem base, que inclui o componente de cápsula.
‫Portanto, todo o conteúdo e os componentes da cápsula também estão dentro de alguma outra classe H e nem são
‫necessários lá.
‫Alguma outra classe que H só precisa saber sobre base em que não se importa com o componente da cápsula.
‫Agora digamos que continuamos este padrão e criamos alguma outra classe chamada ainda outra classe e ainda outra classe
‫pode precisar ter um ponteiro do tipo alguma outra classe agora em vez de declarar para frente.
‫Apenas incluímos alguma outra classe H em outra classe H e agora dentro de outra classe H.
‫Mesmo que nós nem precisemos do cabeçalho para o componente base pond ou cápsula H, nós o colocamos em
‫outra classe porque alguma outra classe inclui esses arquivos de cabeçalho dentro dela.
‫Portanto, temos cópias de todo o conteúdo dos componentes da cápsula e, com base em H, apenas preso aqui em
‫outra classe, aumentando esse arquivo e aumentando os tempos de compilação, tudo porque não enviamos a declaração.
‫Então, em vez disso, a melhor coisa a fazer é incluir arquivos de cabeçalho onde eles são realmente necessários.
‫Portanto, se pegarmos os componentes da cápsula e incluí-los apenas com base no CPP, mais tarde, quando criarmos
‫outra classe e realmente precisarmos usar o pod base, podemos incluir o cabeçalho lá
‫e a base não inclui componentes da cápsula, então todo esse código extra não está incluído em alguma outra
‫classe.
‫E então quando vamos e criamos outra classe que precisa de alguma outra classe, podemos incluir alguma
‫outra classe que h em outra classe que CPP onde é realmente necessário e então outra classe que H
‫não é preenchida com o conteúdo de outros arquivos de cabeçalho que ele não precisa.
‫Portanto, quando as classes têm dependências como essa com base no componente da cápsula, é melhor manter
‫essas dependências no mínimo.
‫Então vou desafiá-lo a criar um erro de compilação.
‫Não devemos ter medo de erros de compilação.
‫Eles são apenas uma parte normal do processo de desenvolvimento.
‫Então, vamos gerar um intencionalmente voltar e remover a palavra-chave class e compilar sem
‫declarar cápsula comp.
‫Agora, quando digo compilar, quero dizer que você pode compilar a partir do código do Visual Studio, apenas uma compilação C++ normal.
‫Você aprendeu como fazer isso ou pode simplesmente salvar seu arquivo e código do Visual Studio e iniciar a
‫codificação ao vivo.
‫Qualquer um deles está bem e, assim que passarmos por isso juntos, mostrarei o que acontece com os dois
‫métodos.
‫Se você usar a codificação ao vivo, é claro que verá a saída gerada na janela de
‫codificação ao vivo, em oposição à saída que você veria no código do Visual Studio.
‫Agora spoiler, você vai receber um erro de compilação, olhe para a mensagem de erro de compilação, veja o que
‫está lhe dizendo.
‫Isso é apenas nos familiarizarmos com os erros que geramos.
‫Depois disso, volte e avance, declare cápsula comp usando a palavra-chave class.
‫Depois de fazer isso, compile novamente, você deve obter uma compilação bem-sucedida desta vez.
‫Pause o vídeo e experimente.
‫Tudo bem, então vamos causar estragos em nosso código aqui.
‫Vou remover a palavra-chave class.
‫Ok, tentamos compilar e aqui está a saída no terminal.
‫A primeira coisa que vemos é um erro e nos dá um código de erro e diz que a cápsula comp não é
‫membro de um peão base.
‫Temos uma nota que diz C declaração de um peão base e então vemos que temos outros erros como
‫resultado disso.
‫Então, muitas vezes os alunos ficam confusos quando tentam compilar e parecem vários erros.
‫Isso mostra que um único erro pode propagar uma série de erros.
‫E isso não significa que você precisa consertar um monte de arquivos.
‫O erro pode ter uma única origem aqui.
‫Sabemos qual é a origem do erro.
‫Precisamos encaminhar declarar.
‫Agora vamos ver o que acontece se usarmos codificação ao vivo em vez de compilação regular e código do Visual Studio.
‫Então, vou em frente e clique no botão para iniciar a codificação ao vivo e imediatamente em vermelho vejo que a
‫compilação falhou e vemos a mesma coisa aqui.
‫Bem aqui.
‫A composição da cápsula não é um membro de uma nota de peão base.
‫Veja a declaração de um peão base.
‫Então vemos a mesma coisa aqui.
‫Então, em ambos os casos, veremos um erro como este quando esquecermos de encaminhar a declaração.
‫Então agora sabemos como é e agora estamos mais informados e com menos medo dessas misteriosas mensagens de erro
‫de compilação.
‫Então, o que vamos fazer é corrigir esse erro, declarando seu componente cápsula e, em seguida,
‫podemos tentar compilar novamente.
‫E agora compilamos sem erros.
‫Então agora vemos como é quando esquecemos de declarar uma variável.
‫Tenha isso em mente quando você receber erros do compilador no futuro.
‫Então, em resumo, discutimos a declaração de encaminhamento ao criar um novo ponteiro e aprendemos
‫que você deve incluir apenas o que usa no arquivo CP e devemos incluir o mínimo possível no arquivo
‫H.
‫Sabemos que não precisamos do arquivo de cabeçalho para declarar um novo ponteiro desde que encaminhemos a declaração e
‫que precisamos do arquivo de cabeçalho se formos construir um objeto de um tipo específico.
‫E precisamos do arquivo de cabeçalho para acessar membros como funções e variáveis e vimos que realmente precisamos
‫do arquivo de cabeçalho para herança para herança de uma classe.
‫Precisamos desse arquivo de cabeçalho lá.
‫Agora que sabemos como encaminhar um tipo e temos nossa composição de cápsula de ponteiro, estamos prontos
‫para construir um objeto de componente de cápsula e faremos isso no próximo vídeo.
‫Vejo você em breve.