C++ para iniciantes | Primorous Arts | Skillshare

Velocidade de reprodução


1.0x


  • 0.5x
  • 0.75x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Aulas neste curso

    • 1.

      Apresentação

      2:45

    • 2.

      Capítulo 1 (configuração): instale o Visual Studio

      4:48

    • 3.

      Capítulo 1 (configuração): coloque todos na mesma página

      3:19

    • 4.

      Capítulo 2 (Hello World): explicando o código

      12:26

    • 5.

      Capítulo 2 (Hello World): espaço em branco

      2:29

    • 6.

      Capítulo 2 (Hello World): escrevendo para o console

      8:12

    • 7.

      Capítulo 2 (Hello World): comentários

      3:45

    • 8.

      Capítulo 3 (variáveis): introdução a variáveis

      6:24

    • 9.

      Capítulo 3 (variáveis): inteiros

      7:42

    • 10.

      Capítulo 3 (variáveis): pontos flutuantes

      6:40

    • 11.

      Capítulo 3 (variáveis): booleanos

      6:24

    • 12.

      Capítulo 3 (variáveis): caracteres

      4:14

    • 13.

      Capítulo 3 (variáveis): cadeias

      8:39

    • 14.

      Capítulo 3 (variáveis): constantes

      4:55

    • 15.

      Capítulo 4 (entrada do usuário): entrada do usuário Cin

      9:32

    • 16.

      Capítulo 4 (entrada do usuário): funções Getchar e Getline

      6:25

    • 17.

      Capítulo 4 (entrada do usuário): cadeia de caracteres para Int

      6:09

    • 18.

      Capítulo 5 (Operadores): aritmética básica

      5:48

    • 19.

      Capítulo 5 (operadores): incremento e decremento

      7:28

    • 20.

      Capítulo 5 (operadores): módulo

      1:55

    • 21.

      Capítulo 5 (operadores): remissão

      2:18

    • 22.

      Capítulo 5 (operadores): concatenação

      4:15

    • 23.

      Capítulo 5 (operadores): fundição e truncamento

      9:02

    • 24.

      Capítulo 6 (condicionais): escopo

      4:01

    • 25.

      Capítulo 6 (condicionais): introdução aos condicionais

      1:27

    • 26.

      Capítulo 6 (condicionais): operadores relacionais e de igualdade

      3:02

    • 27.

      Capítulo 6 (condicionais): operadores lógicos

      2:16

    • 28.

      Capítulo 6 (condicionais): declarações If

      6:36

    • 29.

      Capítulo 6 (condicionais): instruções de aninhamento de If

      6:17

    • 30.

      Capítulo 6 (condicionais): declarações If-Else

      3:07

    • 31.

      Capítulo 6 (condicionais): declarações de Else-If

      7:10

    • 32.

      Capítulo 6 (condicionais): instruções do Switch

      10:44

    • 33.

      Capítulo 6 (condicionais): operador ternário

      9:42

    • 34.

      Capítulo 7 (loops): introdução a loops

      1:05

    • 35.

      Capítulo 7 (loops): enquanto loops

      7:29

    • 36.

      Capítulo 7 (loops): faça enquanto loops

      3:13

    • 37.

      Capítulo 7 (loops): para loops

      7:53

    • 38.

      Capítulo 7 (loops): loops de aninhamento

      3:39

    • 39.

      Capítulo 7 (loops): declarações de quebra

      8:49

    • 40.

      Capítulo 7 (loops): instruções de continuação

      5:40

    • 41.

      Capítulo 7 (loops): validando a entrada do usuário

      14:26

    • 42.

      Capítulo 7 (loops): operador de resolução de escopo

      2:40

    • 43.

      Capítulo 8 (números aleatórios): introdução a números aleatórios

      3:53

    • 44.

      Capítulo 8 (números aleatórios): gerando números aleatórios

      8:19

    • 45.

      Capítulo 9 (recipientes): introdução a recipientes

      1:27

    • 46.

      Capítulo 9 (recipientes): matrizes

      7:52

    • 47.

      Capítulo 9 (recipientes): matrizes multidimensionais

      10:07

    • 48.

      Capítulo 9 (recipientes): vetores

      11:25

    • 49.

      Capítulo 9 (contêineres): filas

      7:13

    • 50.

      Capítulo 9 (recipientes): pilhas

      4:37

    • 51.

      Capítulo 10 (Loops de Forach): introdução aos loops de Foreach

      1:44

    • 52.

      Capítulo 10 (Loops de Forach): Loops de Foreach

      14:08

    • 53.

      Capítulo 10 (Loops de Foreach ): palavra-chave automática

      8:07

    • 54.

      Capítulo 10 (Loops de Foreach ): mapas

      12:12

    • 55.

      Capítulo 10 (Loops de Foreach ): iteradores

      11:07

    • 56.

      Capítulo 11 (Enums): introdução aos Enums

      3:12

    • 57.

      Capítulo 11 (Enums): criando um Enum

      5:11

    • 58.

      Capítulo 11 (Enums): usando Enums

      10:59

    • 59.

      Capítulo 11 (Enums): Eums vs Enum Classes

      4:04

    • 60.

      Capítulo 12 (funções): introdução a funções

      2:39

    • 61.

      Capítulo 12 (funções): criando uma função

      6:46

    • 62.

      Capítulo 12 (funções): protótipos de função

      2:58

    • 63.

      Capítulo 12 (funções): tipos de retorno

      7:49

    • 64.

      Capítulo 12 (funções): parâmetros e argumentos

      6:45

    • 65.

      Capítulo 12 (funções): argumentos opcionais

      5:58

    • 66.

      Capítulo 12 (funções): funções sobrecarregadas

      4:38

    • 67.

      Capítulo 12 (funções): recorrência

      7:32

    • 68.

      Capítulo 12 (funções): matrizes como parâmetros

      8:17

    • 69.

      Capítulo 13 (referências): introdução às referências

      1:28

    • 70.

      Capítulo 13 (referências): criando uma referência

      3:32

    • 71.

      Capítulo 13 (referências): referências e loops de Foreach

      4:01

    • 72.

      Capítulo 13 (referências): referências como parâmetros

      4:17

    • 73.

      Capítulo 13 (referências): referências como tipos de retorno

      7:31

    • 74.

      Capítulo 13 (referências): endereços de memória

      4:20

    • 75.

      Capítulo 14 (ponteiros): introdução a ponteiros

      1:14

    • 76.

      Capítulo 14 (ponteiros): criando um ponteiro

      9:45

    • 77.

      Capítulo 14 (ponteiros): ponteiros nulos

      3:52

    • 78.

      Capítulo 14 (ponteiros): ponteiros e funções

      6:20

    • 79.

      Capítulo 14 (ponteiros): ponteiros e matrizes

      10:44

    • 80.

      Capítulo 14 (ponteiros): ponteiros versus referências

      2:56

    • 81.

      Capítulo 15 (cursos): introdução ao OOP

      4:03

    • 82.

      Capítulo 15 (cursos): criando um curso

      5:59

    • 83.

      Capítulo 15 (cursos): objetos do curso

      1:59

    • 84.

      Capítulo 15 (cursos): especificadores de acesso

      4:32

    • 85.

      Capítulo 15 (cursos): funções do curso

      6:12

    • 86.

      Capítulo 15 (cursos): construtores de curso

      10:32

    • 87.

      Capítulo 15 (cursos): inicializadores de lista

      5:50

    • 88.

      Capítulo 15 (cursos): encapsulamento, abstração e propriedades

      16:11

    • 89.

      Capítulo 15 (cursos): herança

      29:24

    • 90.

      Capítulo 15 (cursos): recapitulação do curso

      27:44

    • 91.

      Capítulo 15 (cursos): palavra-chave estática

      18:07

    • 92.

      Capítulo 15 (cursos): curso vs estrutura

      3:06

    • 93.

      Capítulo 15 (cursos): impeça a criação de curso base

      2:01

    • 94.

      Capítulo 15 (cursos): operadores de acesso de membros

      2:57

    • 95.

      Capítulo 15 (cursos): polimorfismo

      19:00

    • 96.

      Capítulo 15 (cursos): quatro princípios principais do OOP

      5:01

    • 97.

      Capítulo 15 (cursos): funções de amigos e cursos

      8:06

    • 98.

      Capítulo 15 (cursos): espaços de nomes

      8:00

    • 99.

      Capítulo 15 (cursos): matrizes de objetos

      6:56

    • 100.

      Capítulo 15 (cursos): criação de curso alternativo

      11:50

    • 101.

      Parabéns!

      2:06

  • --
  • Nível iniciante
  • Nível intermediário
  • Nível avançado
  • Todos os níveis

Gerado pela comunidade

O nível é determinado pela opinião da maioria dos estudantes que avaliaram este curso. Mostramos a recomendação do professor até que sejam coletadas as respostas de pelo menos 5 estudantes.

345

Estudantes

--

Projeto

Sobre este curso

Descrição

Neste curso abrangente de C++ para iniciantes, vou levar você de não ter conhecimento de programação anterior, para escrever com confiança código em C++, enquanto dominamos os fundamentos e até abordamos tópicos avançados como herança, polimorfismo e interfaces. Com orientação passo a passo, desafios práticos e esclarecimentos sobre não apenas o que fazer, mas por quê, você estará no caminho para construir projetos do mundo real em pouco tempo!

Por que você deveria fazer este curso:

  • Versatilidade: C++ é usado no desenvolvimento de jogos (Unreal), aplicativos móveis, engenharia de software e muito mais.
  • Alta demanda por desenvolvedores de C++: com um salário médio de US $ 100.000+ para programadores qualificados, C++ é um ótimo ponto de partida para uma carreira tecnológica lucrativa.
  • Aprender fazendo: você terá experiência prática com desafios de codificação a partir do Capítulo 3 para ajudar a aplicar o que aprendeu e solidificar sua compreensão dos conceitos ensinados ao longo do curso.

Para quem é este curso

  • Programadores aspirantes a não ter conhecimento prévio de programação.
  • Qualquer pessoa que queira levar suas habilidades em C++ para o próximo nível.
  • Programadores que precisam de uma atualização ou simplesmente querem aprender uma nova linguagem.

Materiais/recursos necessários

  • Um computador (Windows, macOS ou Linux) capaz de correr o Visual Studio ou qualquer IDE de C++ de sua escolha.
  • Não é necessária nenhuma experiência anterior em programação.
  • Todo o software usado no curso é gratuito para uso.
  • Também recomendo ter um teclado físico.

Conheça seu professor

Teacher Profile Image

Primorous Arts

Course Instructor

Professor
Level: All Levels

Nota do curso

As expectativas foram atingidas?
    Superou!
  • 0%
  • Sim
  • 0%
  • Um pouco
  • 0%
  • Não
  • 0%

Por que fazer parte da Skillshare?

Faça cursos premiados Skillshare Original

Cada curso possui aulas curtas e projetos práticos

Sua assinatura apoia os professores da Skillshare

Aprenda em qualquer lugar

Faça cursos em qualquer lugar com o aplicativo da Skillshare. Assista no avião, no metrô ou em qualquer lugar que funcione melhor para você, por streaming ou download.

Transcrições

1. Apresentação: Bem-vindo ao curso Primoris Arts C plus plus para iniciantes Se você está aqui, provavelmente está interessado em aprender a programar, mas não sabe por onde começar. Eu entendi. Eu também estava lá. Quando tentei aprender a programar pela primeira vez, passei mais tempo pesquisando um curso completo, acompanhando o conteúdo do que eu já havia aprendido e/ou respostas para perguntas básicas do que realmente aprendendo. Além disso, eu sentia que estava aprendendo a seguir as regras quando o que eu realmente precisava e queria era saber como as coisas funcionavam e quando usá-las para que eu pudesse começar meus próprios projetos É por isso que criamos este curso para que você não tenha que lidar com essas mesmas dificuldades em sua jornada para se tornar um programador Tudo o que você precisa para começar está aqui, em um só lugar, desde tópicos iniciantes até tópicos avançados, com suporte real disponível quando você mais precisa Então, por que você deveria aprender C plus plus especificamente? C plus plus é uma linguagem versátil e poderosa usada no desenvolvimento de jogos, navegadores da web, bancos de dados e muito mais. Com isso, você terá a base para começar a criar seus próprios projetos em uma escala altamente valorizada no crescente setor de tecnologia. E embora o C plus seja considerado uma linguagem mais difícil de aprender com base na linguagem C, ele pode ser uma ferramenta essencial para quem deseja dominar a programação em áreas onde a programação em áreas onde memória e a velocidade são uma grande preocupação, além de fornecer uma base sólida que torna o aprendizado outras linguagens baseadas em C, como C Sharp ou Java , muito mais fácil. Com isso em mente, este curso começará com o básico absoluto Se você nunca escreveu uma única linha de código, não se preocupe, você vai ficar bem. Vamos nos aprofundar nos fundamentos como variáveis, e gradualmente avançaremos até tópicos mais avançados como classes ou objetos, abstração, encapsulamento, polimorfismo, herança polimorfismo Do capítulo três em diante, você terá a oportunidade enfrentar desafios de codificação projetados especificamente para ajudá-lo a solidificar sua compreensão dos conceitos ensinados ao longo do curso Então, por que você deve escolher este curso para aprender C plus? Porque, em vez de apenas mostrar como seguir em frente e fazer com que você termine com um projeto que você não tem ideia de como recriar sozinho, vou te ensinar não apenas como escrever o código, mas, o mais importante, quando usá-lo e Ao ensinar você a pensar como um programador, você realmente obterá uma compreensão muito mais profunda de cada conceito ensinado para que , ao final do curso, esteja pronto para enfrentar seus próprios projetos com confiança E para tornar as coisas ainda melhores, tudo o que usamos neste curso é gratuito, o que significa que não há testes gratuitos ou taxas ocultas com que se preocupar. Agora, para quem é esse curso? Este curso é perfeito para iniciantes que desejam começar, programadores experientes que desejam atualizar ou expandir suas habilidades e todos E lembre-se, não há pressa. Sinta-se à vontade para seguir seu próprio ritmo e voltar e revisitar aulas específicas quando necessário Aqui na Primoris Arts, estamos comprometidos em ajudá-lo a ter sucesso em cada etapa do processo Então, se você está pronto para começar sua jornada de programação , não há melhor momento do que agora Convidamos você a se juntar a nós hoje no próximo vídeo, enquanto mergulhamos na programação passo a passo com aulas claras, concisas e fáceis de seguir Obrigado por assistir, e nos vemos na próxima. 2. Capítulo 1 (configuração): instale o Visual Studio: Bem-vindo ao primeiro episódio do curso C plus plus para iniciantes. Neste episódio, mostrarei como instalar o Visual Studio, um programa totalmente gratuito que usaremos para escrever e executar todo o nosso código. Agora, infelizmente, se você estiver em um Mac OS ou Linux, precisará baixar outro programa que permita escrever e executar o código C plus plus. Mas não se preocupe, depois de fazer isso, você poderá acompanhar muito bem. E há vários programas gratuitos disponíveis, bem como muitos tutoriais on-line sobre como começar a usá-los. Em seguida, no próximo episódio, garantirei que todos estejam exatamente na mesma página para que você possa acompanhar, independentemente do programa que estiver usando. Muito rápido aqui e apenas alguns exemplos de alguns programas que eu recomendaria. Se você estiver no macOS ou no Linux. Você pode usar o Visual Studio Code. Outro que você pode usar são os blocos de código. E, por fim, especificamente para usuários do macOS, você pode usar o software Xcode integrado. De qualquer forma, para todos vocês que usam o Windows, Visual Studio é o programa mais popular e o que eu recomendaria usar, pois é muito fácil de configurar e começar. Portanto, a primeira coisa que você vai querer fazer é acessar o Visual Studio.Microsoft.com. Em seguida, na parte superior, vá para downloads. Em seguida, você verá seu Visual Studio com C plus plus. Vá em frente, vá até a caixa suspensa de download e vá até onde está escrito Community Free. Certifique-se de não clicar no que diz teste gratuito. Depois de baixado, abra o aplicativo de configuração do Visual Studio e aceite todas as solicitações que possam aparecer na tela. Em seguida, aguarde até que o download e a instalação sejam concluídos. Agora, depois de concluir a instalação, você pode criar uma conta gratuita, se quiser. Acredito que isso fará com que você crie uma conta em algum momento, mesmo que o programa seja totalmente gratuito. No entanto, neste momento, vou seguir em frente e continuar sem uma conta. Dessa forma, nenhuma das configurações anteriores da minha conta está lá e que possamos revisar tudo junto com uma nova e caveira. Então, vou clicar em “Não agora”, talvez mais tarde. Agora, eu recomendo usar um tema escuro. Não apenas um Visual Studio, mas qualquer programa que você use para escrever código no futuro, pois definitivamente será muito melhor para você. Então, quanto às configurações de desenvolvimento, vou continuar e deixá-las em geral. Em seguida, vamos em frente e clicaremos em Iniciar o Visual Studio. Tudo bem, uma vez aberto, vamos prosseguir e criar um novo projeto. E o que você vai pesquisar aqui no topo é C plus, plus. Outra coisa que você pode fazer é ir até onde está escrito todos os idiomas e clicar em C plus plus. E você deve ver um para aplicativo de console. Então, vou clicar nele e clicar em Avançar. Então você vai dar um nome ao seu projeto. Agora, você pode dar o nome que quiser, mas eu recomendo seguir uma convenção de nomenclatura Pascal Case. O que significa que você não terá nenhum espaço. Você começará com uma letra maiúscula e todas as palavras subsequentes também começarão com uma letra maiúscula. Então vá em frente e dê um nome rápido. Agora, você notará que o nome da sua solução aqui na parte inferior é exatamente igual ao nome do seu projeto. Para este curso. Vamos seguir em frente e deixar as coisas assim. Mas saiba que, no futuro, solução e o nome do projeto não precisam ser os mesmos. Além disso, você pode escolher qualquer local que desejar para este projeto. Em seguida, certifique-se de que esta caixa aqui na parte inferior diz play solution in project no mesmo diretório. Como não verificado. Como isso geralmente é uma boa prática. Em seguida, vá em frente e clique em Criar. Tudo bem, então você pode ir em frente e fechar isso. E aí está. Agora instalamos o Visual Studio e criamos nosso primeiro projeto C Plus Plus. Agora, o que eu quero que você faça é acessar o arquivo na parte superior e clicar em Salvar tudo, e certifique-se de fazer isso no final de cada vídeo, a menos que seja indicado o contrário. Agora, eu sei que nem todos vocês estão usando o Visual Studio. Então, no próximo vídeo, vou me certificar de que todos vocês estejam exatamente na mesma página que eu e estejam prontos para aprender a ler e escrever código juntos. E não se preocupe, esses são os únicos programas que instalarei durante todo o curso. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 3. Capítulo 1 (instalação): coloque todos na mesma página: Neste vídeo, vou garantir que todos vocês estejam exatamente na mesma página que eu, para que possam acompanhar facilmente o resto do curso. E lembre-se, se precisar de alguma ajuda. Informe-me na seção de discussão abaixo e ficarei mais do que feliz em ajudá-lo. De qualquer forma, vamos começar. Agora, bem rápido, para aqueles que estão usando o Visual Studio, vamos até as ferramentas na parte superior e desceremos para Opções. E, abaixo do bug, clique em Geral. Em seguida, desça até o final. E você deve ver uma caixa de seleção que diz fechar automaticamente o console ao carimbar a depuração. Verifique se isso está marcado. Em seguida, vá em frente e clique em OK. Então, independentemente do programa que você está usando, se você tiver outros textos fora dessa hashtag, inclua a linha iostream neste colchete fechado. Então, tudo aqui, vá em frente e se livre de todo o resto. Assim. Ok, então essa deve ser a única coisa que resta na sua tela. Agora, se isso não estiver na sua tela, vá em frente e copie exatamente. Agora, quando seu código se parecer com o meu, vamos realmente adicionar algumas linhas extras de código. Agora, não se preocupe, você não precisa entender nada disso. Vamos falar sobre isso tudo no próximo vídeo. Mas, por enquanto, eu só quero ter certeza de que o código de todos está funcionando. Então, logo após essa linha do HelloWorld aqui, logo após o ponto e vírgula, vamos clicar em Enter para criar uma nova linha. E vamos digitar std, dois pontos, dois pontos, ponto C, abrir parênteses, fechar parênteses, ponto e vírgula. Em seguida, pressionaremos Enter novamente. Eles criam uma nova linha. Vou digitar return. Em seguida, o número 0 seguido por outro ponto e vírgula. Portanto, o código de todos deve ser exatamente assim. Agora, independentemente do programa que você está usando, você deve ser capaz de executar o código como ele está. Agora, para aqueles que usam o Visual Studio, basta clicar neste botão Jogar aqui na parte superior, ou o hóquei é F5. Agora, para aqueles que usam outro programa, você precisará descobrir como executar seu código. E se houver uma tecla de atalho para fazer isso, eu definitivamente recomendaria lembrá-la , pois faremos isso muito ao longo deste curso. De qualquer forma, uma vez que seu código é executado, eu deveria simplesmente dizer olá mundo. E quando você pressiona Enter, eu deveria sair do código. Assim mesmo. Agora, todos vocês podem não ter uma janela de console que aparece quando seu código é executado. E está perfeitamente bem. Desde que seu código seja executado e diga “Olá, mundo”, você está pronto para começar. Quanto ao resto de vocês, a primeira coisa que quero verificar seu código se parece exatamente com o meu. Então, se você ainda estiver tendo problemas, informe-me na seção de discussão abaixo e ficarei mais do que feliz em ajudá-lo. Enfim. Isso é tudo para este vídeo. No próximo vídeo, veremos o que todo esse código realmente significa. Então, obrigado por assistir, e nos vemos na próxima. 4. 3: Neste vídeo, abordaremos brevemente todo o código que temos aqui. Agora, não se preocupe, não espero que você se lembre de tudo, pois abordaremos tudo isso com mais detalhes posteriormente no curso. Eu só quero dar uma breve introdução o que está acontecendo. E no final do vídeo, darei um breve resumo dos poucos pontos-chave que quero que você lembre à medida que avançamos. Então, no início, temos essa declaração de inclusão, que basicamente diz ao compilador que queremos pegar o código do arquivo de cabeçalho chamado iostream e colocá-lo em nosso programa. O compilador é o que traduz tudo aqui em binário ou uns e zeros para que nosso computador possa realmente entendê-lo. E um arquivo de cabeçalho é basicamente apenas uma coleção de códigos criados para serem usados por outros programas. A seguir, temos nossa função principal. A função principal é importante porque todo programa C plus plus tem uma função principal, pois é aqui que seu programa começará e terminará. E tudo o que faz parte da função principal precisa ser colocado entre esses colchetes encaracolados abertos e fechados. E é aqui que a maior parte do nosso código será escrita. Em seguida, temos essa linha de código que imprime Hello world. E vamos detalhar isso rapidamente. Então, primeiro escrevemos std, que é um namespace que contém uma definição para o objeto C out. E voltaremos aos namespaces aqui em um minuto. Agora, veja como um objeto usado para exibir texto. E é sempre seguido pelo operador de inserção, que é dois a menos que símbolos. E o que está à direita do operador de inserção é o que você realmente deseja imprimir. Quando você quiser imprimir textos literalmente ou quiser imprimir exatamente o que você digita. Você precisa tê-lo entre duas aspas duplas, assim. E toda essa linha aqui como uma declaração ou instrução para o nosso programa. E na maioria das declarações terminaremos com um ponto e vírgula. Então, para resumir, estamos basicamente dizendo que queremos usar o objeto C out para imprimir hello world. Então, essa linha que adicionamos no último vídeo basicamente diz que queremos receber informações do usuário. E a única razão pela qual colocamos isso aqui é para que nosso programa não seja encerrado imediatamente após a execução. Como de costume, uma vez que um programa tenha executado todas as suas linhas de código, ele assumirá que está pronto e será encerrado automaticamente. Agora, dependendo do programa que você está realmente usando para escrever código, seu código pode permanecer aberto com ou sem essa linha. Mas para aqueles que precisam, vou deixá-lo aqui na tela como um lembrete. Então, só para mostrar rapidamente, se eu me livrasse dessa linha de código e tentasse executar meu programa, ela seria executada instantaneamente e, em seguida, desligada imediatamente. Então, se eu colocar isso de volta e executar meu código novamente, agora preciso pressionar Enter para fechar. Agora, na verdade, ele me permitirá digitar várias letras e números. Mas quando eu clicar em Enter, ele será desligado imediatamente. E isso ocorre porque esse método get aqui está essencialmente esperando. Eles recebem a opinião do usuário e , presumindo que você tenha terminado ao pressionar a tecla Enter. E, por fim, temos essa declaração de retorno aqui na parte inferior, que diz apenas que queremos retornar o número inteiro zero. E a razão pela qual estamos retornando zero é porque nossa função principal tem um tipo de retorno de um inteiro. Uma vez que o código que chama nossa função principal recebe esse zero. E esses são códigos executados com sucesso. E algo que você pode ver aqui, intercambiável com o zero, é sucesso da saída com um sublinhado entre e em maiúsculas. Assim. Isso vai funcionar muito bem. Como em C plus, plus. Isso é exatamente o mesmo que colocar os números reais zero. E, na verdade, vou deixar as coisas assim para maior clareza. Para aqueles de vocês que precisam disso. No entanto, dito isso, C Plus Plus realmente permite que você remova essa linha e ela retornará zero automaticamente. Mas, como eu disse, vou deixar isso aqui por uma questão de clareza, pois é isso que realmente está acontecendo em segundo plano. Então, bem rápido, vamos voltar ao namespace std. O namespace é basicamente isso mesmo. É um espaço nomeado no qual o código reside. E você pode pensar nisso como o sobrenome de uma pessoa, por exemplo, se eu acabei de mencionar o primeiro nome de alguém para você, você pode não saber de quem eu estava falando, mas se eu dissesse o sobrenome dela, então, quando eu disse o primeiro nome deles, você não tem contexto sobre a quem eu estava me referindo. Exatamente. É o mesmo com nosso código aqui. Então, quando dizemos que sin como parte do std, namespace e nose foram enviados como provenientes apenas no caso de haver outros objetos que também tenham o mesmo nome. E esse namespace std vem desse arquivo de cabeçalho iostream, que é usado para entrada e saída padrão, e é por isso que você verá esse arquivo de cabeçalho usado e muitos programas C plus plus. Então, algo que podemos fazer, em vez de colocar esse namespace antes de tudo o que faz parte desse namespace tem no topo aqui, logo abaixo da nossa declaração de inclusão. Podemos dizer usando namespace. Std e depois um ponto e vírgula no final. E agora ele saberá automaticamente de onde esses objetos estão vindo. E abordaremos os objetos mais tarde no curso. As C plus plus é uma linguagem de programação orientada a objetos. Então, agora que estamos dizendo que estamos usando esse namespace e ele sabe de onde vêm esses objetos, podemos simplesmente remover esse prefixo aqui completamente. Assim mesmo. E se eu executar o programa, você pode ver que ele funciona bem. No entanto, dito isso, algumas pessoas gostam de deixá-las lá por uma questão de clareza. Mas eu, pessoalmente, prefiro apenas digitar C ou CN, já que eles são usados com tanta frequência. Então, vou removê-lo assim e salvar o programa. E é isso que usaremos daqui para frente. Portanto, certifique-se de que vocês tenham essa linha de código e estarão todos envolvidos. Por fim, vamos voltar a este texto do Hello World aqui. Você pode estar se perguntando o que é essa barra invertida n e por que ela não apareceu quando executamos nosso código. Então, como você pode ver, quando eu executo um código, ele diz Hello world, ponto de exclamação. Então nosso cursor está piscando aqui na parte inferior. E isso porque essa barra invertida n diz que queremos ir para uma nova linha. Então, vamos remover isso rapidamente e executar nosso código novamente. E, como você pode ver, nosso cursor está agora no final da linha. Então, essa barra invertida n basicamente diz que queremos ir para uma nova linha. Agora, e se você quisesse escrever mais texto na nova linha? Alguns de vocês podem instintivamente agir assim. Makerspace, olá, comece e execute esse código. Mas você notará que esse espaço está realmente registrado como um espaço na nova linha. Então, se não quisermos isso, teremos que remover o espaço daqui. Porque, como eu disse antes, tudo entre essas aspas duplas será impresso literalmente ou exatamente. No entanto, essa barra invertida é na verdade, um caractere de escape especial que lerá o próximo caractere depois dele e fará algo específico com ele. E havia uma lista completa de sequências de escape especiais que você pode usar. E vamos analisar alguns como exemplo. A primeira é a barra invertida n, que você já viu para criar uma nova linha. Você também pode usar barra invertida, barra invertida para realmente imprimir uma barra invertida. Assim. Outra seria uma barra invertida entre aspas. Para realmente imprimir uma aspa. Em vez de significar o fim do nosso tempo. Eu executo um código. Você pode ver as aspas duplas ali mesmo. De qualquer forma, vamos remover isso e colocar a barra invertida n como o fundo era assim em um piscar de olhos, algo que você pode ver em vez da barra invertida n é o seguinte. Então, depois de uma aspa dupla, você pode ver outro operador de inserção seguido pelo final da palavra com um l minúsculo, como esse. E então garante que o ponto e vírgula ainda esteja no final. Se executarmos nosso código. Isso também se resumirá a uma nova linha. E L é simplesmente a abreviação de linha N. E você pode usá-los de forma intercambiável pois eles fazem exatamente a mesma coisa, apenas para lembrar que a barra invertida precisa entrar em suas aspas. E a extremidade L precisa estar sozinha depois outro operador de inserção, assim. De qualquer forma, vou voltar a colocar isso do jeito que era. Agora bem rápido. Algo que eu gostaria de mencionar é que embora eu tenha chamado isso de função principal, você pode ouvir as pessoas dizerem que método principal como método de função é frequentemente usado de forma intercambiável. E você pode estar acostumado com as pessoas dizendo método, especialmente se você vem de outra linguagem de programação. De qualquer forma, vamos recapitular rapidamente, enquanto temos uma tela. Então, primeiro, temos essa declaração include, que basicamente diz que queremos usar código do arquivo de cabeçalho iostream. Então, estamos dizendo que vamos usar o namespace std, que diz ao nosso programa que esse objeto c de saída e envio vem do namespace std. E como eu disse, você pode basicamente pensar um namespace como o sobrenome de alguém. E, basicamente, apenas uma forma especificar de onde algo está vindo ou a que estamos nos referindo. Quando dissemos scalp, eles sabem que queremos usar c fora do namespace std. Tudo bem, então estamos incluindo o código do iostream. Esses dois objetos aqui, sendo C out e C n, vêm do nome space std. Então temos nossa função principal, ou um método que faz parte do programa array C plus plus, pois é aqui que nosso programa começará e terminará. E dentro daqui, temos apenas algumas declarações. Temos esse primeiro, que é o objeto CL para imprimir Hello World. Temos esse sin.gov, que basicamente está esperando a entrada do usuário. E então simplesmente temos isso para que nosso programa não feche imediatamente até pressionarmos a tecla Enter. Então, temos sucesso na saída de retorno, que é o mesmo que dizer retorno zero, pois nossa função principal precisa retornar um valor inteiro ou um número inteiro. E normalmente retornará zero quando tiver êxito e sua operação. Então, isso e isso são exatamente a mesma coisa. E como eu disse, o C plus plus na verdade permitirá que você simplesmente remova isso e digite. Tudo bem, de qualquer forma, isso é tudo para este vídeo. Certifique-se de que vocês vejam o que vocês têm. E não se preocupe se você não lembrar de tudo o que falamos aqui. A única coisa que eu realmente quero que você se lembre daqui para frente é que o código R ocorrerá dentro da função principal. E então, todo programa C plus plus tem uma função principal, porque é aqui que nosso programa começa e termina. E daqui em diante, vamos dividir cada pequena coisa passo a passo em seu próprio vídeo individual que você possa acompanhar com facilidade, verdade compreenda o que está acontecendo para que você possa usá-lo em seus próprios programas. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 5. Capítulo 2 (Hello World): Espaço branco: Neste vídeo, falaremos sobre espaços em branco. Espaço em branco e C plus baseiam-se nos dois primeiros caracteres que são usados para fins de formatação, como espaços e tabulações em algumas linhas novas. E o compilador C plus plus ou a coisa que está pegando todo esse código e convertendo-o em binário para que o computador possa entendê-lo geralmente ignorará os espaços em branco. No entanto, há algumas exceções que abordaremos neste vídeo. Então, para dar um exemplo de espaço em branco, você pode usar quantas linhas novas, quantas vezes, quantos espaços quiser, geral. Mesmo entre as coisas. Portanto, seu código funcionará perfeitamente. Ok? Então, basicamente, você quer usar espaços em branco para tornar o código o mais legível possível para você. E se você estiver trabalhando com outras pessoas, convém torná-lo o mais legível possível para elas também. Então, quando o espaço em branco não é ignorado? Bem, quando usamos aspas para dizer ao nosso programa que queremos que ele imprima exatamente o que está entre elas. Ele pressupõe que, quando colocamos um espaço, queremos espaçar. Então, quando colocamos um espaço aqui entre olá e mundo, mas aparecemos e nosso programa. Como em qualquer outro espaço com o qual brincamos aqui. Como você pode ver aqui. A outra vez é quando temos um operador que usa dois caracteres, como com nosso operador de inserção aqui. Se você colocasse espaços no meio, ele não entenderia mais o que era isso. E então, na verdade, há apenas uma outra vez em que o compilador não ignorará os espaços em branco. E é quando você tem uma palavra-chave como return here, você não pode separá-la assim. E aí está. Agora você conhece os espaços em branco como na programação C plus plus. Basicamente, você pode usar quantas linhas novas, espaços e abas quiser para tornar seu código o mais legível possível. Com exceção de não ser capaz de separar as palavras-chave. Qualquer espaço em que você diga ao seu programa que deseja que ele imprima exatamente o que você deseja. E você não pode dividir operadores que tenham dois ou mais caracteres. Enfim. Obrigado por assistir, e nos vemos na próxima. 6. Capítulo 2 (Hello World): Escrever para console: Neste vídeo, vamos voltar e ver como imprimir textos no console. Portanto, a maneira principal de proteger o console e o C plus, plus, como com um objeto C, seguido pelo operador de inserção. Lembre-se de que, se por algum motivo, seu código não aceitar isso, é porque você precisa incluir o iostream. E você vai querer deixar seu código agora que está usando o namespace std. Caso contrário, você pode dizer explicitamente que é do namespace std, digitando S, T, D, dois pontos, dois pontos, seguido por C out. Mas, por enquanto, vou remover isso. Como já declaramos que estamos usando esse namespace aqui. E eu, pessoalmente, acho isso muito mais fácil de ler. Então, vou limpar isso um pouco para que saibamos todo o nosso código aqui. Então eu gostaria que vocês acompanhassem. E basicamente vamos remover essa linha e escrever textos no console do zero. Então, vamos sair e nos livrar disso. E sempre que você quiser escrever textos no console, você só vai dizer C em letras minúsculas. Sim, a capitalização importa quando se trata de programação. Seguido pelo operador de inserção. Então, vamos dizer C fora do espaço, o operador de inserção colocado em outro espaço. E então, entre aspas, digitaremos o que quisermos dizer. Então eu poderia dizer, ouça muitos textos de primeiro nome e fique à vontade para colocar o que quiser lá. E depois da última aspa, você simplesmente inserirá uma declaração com um ponto e vírgula. E então executamos nosso código. Eles dirão que esta é minha primeira linha de texto e nosso cursor ficará lá no final. Porque não inserimos se quiséssemos que fosse para uma nova linha. Tudo bem, então aí está. É assim que você pode imprimir uma única linha de texto no console. Mas e se você quisesse imprimir várias linhas? Bem, você tem algumas opções. Você sempre pode dizer a barra invertida n. e depois dizer algo como: “ Esta é a minha segunda linha”. E quando seu programa, e aí está. E você pode fazer isso quantas vezes quiser. Agora, embora pudéssemos continuar digitando barra invertida n seguida por qualquer texto extra que desejemos escrever. Isso acabará ficando muito confuso e dificultará a leitura do nosso código. Então, temos outra opção. Vamos prosseguir e remover esse código extra aqui. Então, vamos copiar e colar essa linha abaixo. E diremos algo como, Esta é minha segunda linha. Como eu disse, fique à vontade para jogar o que quiser lá. E então vamos seguir em frente e executar nosso código. E como você pode ver, diz apenas que esta é minha primeira linha de texto. Então esta é minha segunda linha de texto sem espaços, sem pontuação. Não está em uma nova linha. Nada. Isso porque, na programação, seu código fará exatamente o que você mandar. E não vai fazer nada a mais para te ajudar. Então, basicamente, se você quer que algo aconteça, você tem que fazer isso acontecer. Então, se quisermos limpar isso e fazer com que apareça em qualquer linha, tenha alguma pontuação lá, coisas assim. Teríamos que digitá-lo manualmente. Então, posso dizer que esta é minha primeira linha de texto. Período. barra invertida n criará uma nova linha. E então você pode colocar um ponto final. Eu acho que esse também. Quando eu codifico novamente e aí está. Provavelmente um pouco mais perto do que você esperava antes. E se você quiser uma linha em branco entre essas duas linhas, bem, você pode simplesmente colocar outra barra invertida n no começo aqui. E aí está. Você tem uma nova linha. E você pode realmente continuar fazendo isso para obter mais novas linhas intermediárias. Se você escolher. De qualquer forma, vou remover isso. E se você se lembrar de nossa outra opção, em vez de dizer barra invertida n e algo que você também pode ver com frequência seria depois de aspas duplas para colocá-la em outro operador de inserção. Insight end l, tudo em minúsculas. E antes do ponto e vírgula. Então, se executarmos um programa novamente, você poderá ver que ele funciona muito bem. Se você se lembra, eu disse que o espaço em branco geralmente pode ser ignorado pelo C plus plus. Então, se eu voltasse e removesse todos os espaços entre C do operador dela, as aspas aqui. E no final, aqui, eu vou programar. Ainda funcionaria muito bem. No entanto, eu simplesmente disse a vocês que colocassem um espaço, pois escrevemos isso para facilitar a leitura, pois algo que você sempre desejará fazer quando se trata de programação é criar seu código como legível quanto possível. Porque embora você possa construir uma leitura e compreendê-la hoje, você pode pensar que qualquer outra pessoa que a veja também pode entendê-la. Você quer ter certeza de que pode entender isso amanhã, daqui a uma semana, um mês ou até anos depois , sem problemas. E isso é algo que eu quero que você tenha em mente e pratique enquanto continuamos neste curso. De qualquer forma, isso é basicamente o suficiente para imprimir texto. Mas vou te mostrar um último truque. Então, assim como podemos adicionar outro operador de inserção para inserir essa linha N aqui para criar uma nova linha. Também podemos simplesmente colocar os textos lá. Então, em vez de criar uma declaração C out totalmente nova, pode realmente copiar esse texto junto com as citações. Livre-se totalmente dessa linha. E depois desse operador de inserção extra, podemos simplesmente colar em nossa linha. E, na verdade, vou colocar isso em uma linha separada para que tudo permaneça na tela aqui. Assim mesmo. E isso vai funcionar muito bem. E poderíamos até mesmo colocar nossa linha M aqui junto com outro operador de inserção intermediário. E tudo isso funcionará como antes. Você vai. Então, sempre que você usar o objeto CLI para imprimir texto na tela, vou me certificar de que você inclua o iostream, ou seja, de onde vem o objeto. E quando eu passo o mouse sobre ele, você pode ver que ele vem do namespace std, que declaramos aqui. Em seguida, sempre o seguimos com o operador de inserção, que inserirá o que colocamos depois em nosso programa. Então, sempre que quiser adicionar mais de uma coisa, basta segui-la com outro operador de inserção. Então dissemos C para fora. Em seguida, dissemos que queremos colocar exatamente o que está entre essas aspas duplas na tela. Então ele disse Esta é a nossa primeira linha de texto. Coloque outro operador de inserção. Coloque uma linha final aqui para indicar que queremos descer para uma nova linha. E se você se lembrar, também codificamos, basta colocar a barra invertida n, assim. Então, como estamos adicionando outra coisa, colocamos outro operador de inserção. E então colocamos outra linha literal de textos que queremos que seja impressa no console, representada por aspas duplas novamente. Por fim, no final desta declaração OU instrução para o nosso programa, simplesmente colocamos um ponto e vírgula. De qualquer forma, usaremos o objeto CL várias vezes ao longo deste curso. Portanto, não se preocupe, se você não tiver tudo pronto agora, você terá uma tonelada de prática prática. E só para recapitular rapidamente a sintaxe ou as regras sobre como escrever textos no console. Você simplesmente dirá Cl, seguido pelo operador de inserção, seguido por aspas duplas e um ponto e vírgula no final. E dentro dessas citações é para onde seu texto vai parar. E você pode até mesmo não colocar nada lá e funcionará muito bem. Então vá em frente e brinque um pouco com isso. Assista novamente ao vídeo, se precisar, e nos vemos no próximo. 7. Capítulo 2 (Hello World): Comentários: Neste vídeo, falaremos sobre comentários na programação. Muito rápido. Vamos remover todo esse código extra fora da declaração da Cintiq e da nossa declaração de devolução. Então, quais são nossos comentários e programação, bem, eles são basicamente o que você pensa. Um comentário é basicamente textos que você mesmo escreve para tornar seu código mais legível. Então, bem rápido, vamos colocar de volta em nossos textos. Estamos escrevendo Hello World para o console. Então, vamos dizer C out, operador de inserção. E então, entre aspas, venha dizer olá mundo. E não se esqueça do ponto e vírgula no final. Então, já trabalhamos com esse programa algumas vezes. Nós já sabemos o que ele faz. Quando executamos nosso código. Simplesmente dirá Hello World em uma única linha. Mas e se quiséssemos adicionar algumas linhas próprias para tornar esse código mais legível. Agora, agora, entendo que nosso programa é bem pequeno e básico e isso não é muito necessário. Mas à medida que avançamos e começamos a trabalhar com programas mais complexos, você definitivamente desejará adicionar o máximo de comentários possível para tornar seu código o mais legível possível. Porque mesmo que você saiba o que diz hoje, você quer poder ver isso daqui a alguns anos, quando não se lembrar de ter escrito nada disso e ainda ser capaz de lê-lo. Sem problema. Então, como escrevemos um comentário? Em qualquer linha do nosso código aqui, podemos colocar duas barras e tudo depois dessas duas barras será completamente ignorado. Quando executamos nosso programa. Você coloca um texto como esse e executa nosso código. E vai dizer HelloWorld, assim como eu fiz antes. Neste comentário, terminará automaticamente quando descermos para uma nova linha. Agora, existe uma maneira de fazer comentários que passarão por várias linhas. Então, se você digitar uma barra seguida pelo símbolo real, tudo além desse ponto será um comentário. Como você pode ver, ele comentou tudo além disso. O caminho para n, esse é o que é outro símbolo Astro seguido pela barra para frente novamente. Então, como você pode ver, isso por mais que eu queira aqui, mas uma nova linha. E tudo funcionará exatamente como eu fiz antes. Aí está você. De qualquer forma, vou remover isso para que você o tenha. Agora você já sabe como adicionar comentários ao seu código para torná-lo mais legível. Mas há mais um caso de uso para comentários, que é incrivelmente útil, que abordarei com você agora. Então, como qualquer coisa dentro de um comentário será ignorada, você pode realmente criar uma ou várias linhas de código para testar seu programa sem elas. Isso pode ser extremamente útil ao tentar descobrir o que está causando um problema ou apenas para ver como seu código é executado sem algo. Então, por exemplo, vamos copiar e colar essa linha do HelloWorld algumas vezes. Assim mesmo. E vamos comentar alguns deles. Assim, eu poderia executar meu código exatamente como antes. Mas só vai imprimir Hello World três vezes porque esta quarta aqui está comentada. Agora, obviamente, esse não é um bom exemplo de quando usar isso, mas faremos isso durante todo o curso. Assim, você terá alguma experiência prática de usar isso a seu favor. Mas eu só queria que você soubesse disso o máximo possível e informá-lo sobre todos os casos de uso para comentários. De qualquer forma, isso é tudo para este vídeo bem rápido. Eu só quero mencionar isso a partir de agora, quando eu estava começando cada vídeo com uma ficha limpa que se parece com esta. E faremos isso a partir de agora, salvo indicação em contrário. Então, obrigado por assistir e nos vemos na próxima. 8. Capítulo 3 (Variáveis): Introdução a variáveis: Neste vídeo, falaremos sobre variáveis. Uma variável é basicamente apenas um contêiner para armazenar valores de dados ou um nome dado a um local de memória. Até agora, aprendemos como imprimir algo para o usuário. Mas e se realmente quiséssemos recuperar as informações? Ou se quiséssemos informações às quais pudéssemos nos referir, acessar e manipular posteriormente? Bem, é aí que as variáveis entram em jogo. Então, como criamos uma variável? Bem, vamos repassar isso. Portanto, a sintaxe para criar uma variável ou as regras de como criar uma variável é a seguinte. Primeiro, você vai começar com o tipo de dados. E isso representa o tipo de dados que você deseja armazenar dentro da variável. Talvez você queira armazenar números, palavras, caracteres ou um valor verdadeiro ou falso, etc. E veremos os diferentes tipos de dados nos próximos vídeos. Depois do tipo de dados, você colocará o nome da variável. Agora, ao nomear uma variável, você quer ter certeza de que seu nome é descritivo do que você está armazenando. Então, por exemplo, digamos que você estivesse fazendo um jogo de pinball. Você queria armazenar a pontuação atual. Em vez de apenas chamar esse número um, talvez queiramos chamá-lo de pontuação atual. Então, talvez queiramos outra variável para armazenar a pontuação mais alta, por exemplo. E não gostaríamos de nomeá-los de acordo. Agora, ao nomear uma variável, existem algumas convenções de nomenclatura comuns que eu recomendo que você use, pois você as verá com bastante frequência. E especialmente se você estiver trabalhando com outras pessoas, é provável que isso também seja o que elas farão. Então, geralmente, ao nomear uma variável, ela sempre começa com uma letra minúscula. Além disso, eu recomendaria escrevê-lo no estilo CamelCase, o que significa que a primeira letra será minúscula. Não haverá espaços ou pontuação. E no início de cada palavra subsequente após a primeira, começaremos com uma letra maiúscula. A outra opção, que você verá com frequência para nomear variáveis, é que o caso de cobra garante aqueles que as separam apenas com uma letra maiúscula no início de cada palavra subsequente até a 1ª, você apenas os separará com um sublinhado. E então você pode deixar a primeira letra minúscula assim. Agora, no restante deste curso, escreverei nossas variáveis com uma primeira letra minúscula e depois com maiúsculas e minúsculas de Kimball. Porque o z é o mais frequente e acho mais fácil ler pessoalmente. Então, vou continuar escrevendo o nome da variável, assim. E mostrarei outras convenções de nomenclatura quando se trata outras coisas, à medida que continuamos durante o curso. Então, para declarar uma variável ou basicamente declarar que você precisará de uma variável. Neste programa, vamos começar com um tipo de dados, seguido pelo nome e depois por um ponto e vírgula no final. E então você tem que criou uma variável. Como eu disse nos próximos vídeos, abordaremos os diferentes tipos de dados e como criá-los especificamente e seus casos de uso. Agora, antes de realmente usarmos essa variável e inserirmos o código, precisamos dar a ela um valor inicial. Há algumas maneiras de fazer isso. Então, primeiro de tudo, digamos que essa variável estava armazenando um número inteiro. Ok, então temos nosso tipo de dados para armazenar um número inteiro. E então vamos chamar isso de pontuação. Por exemplo. Digamos que isso foi um placar e um jogo de futebol ou algo parecido. Bem, poderíamos definir seu valor inicial igual a 0, assim. Isso é perfeitamente válido e agora declaramos e damos à nossa variável um valor inicial para que possamos usá-la no futuro. Você nunca gostaria de usar uma variável antes de dar a ela um valor inicial, pois você acaba com vários erros. Outra opção seria declará-lo agora, como já fizemos, e dar a ele um valor inicial posteriormente. Então, deixe-me mostrar como isso parece. Então, depois de declararmos uma variável aqui em cima, podemos referenciá-la e dar a ela um valor inicial posteriormente em nosso código. Então, como fazemos isso? Primeiro, apenas dizemos o nome da variável que queremos referenciar. Então, podemos dizer escopo e, em seguida , dar a ele o valor que queremos. Então, eu poderia dizer que é igual a cinco. Por exemplo. Isso também funcionaria. Desde que atribuamos um valor às nossas variáveis antes usá-las posteriormente, estamos prontos para começar. Agora, há outra forma de declarar e inicializar variáveis que eu vou te mostrar agora. Mas, pessoalmente, eu realmente não recomendaria isso. Mas caso você veja, eu quero que você saiba que está lá fora. E quem sabe, talvez você decida usá-lo em um projeto futuro. Então, o que vou mostrar é como declarar e inicializar várias variáveis na mesma linha. Então, podemos dizer o tipo de dados seguido pelos nomes das variáveis que você deseja desse mesmo tipo de dados. Então, por exemplo, digamos que eu queira criar várias variáveis para armazenar números. Eu o colocaria no tipo de dados adequado, seguido pelo nome da minha primeira variável. Então, vou dizer var um, por exemplo, separado por uma vírgula. E então eu posso fazer quantas variáveis eu quiser. Eu posso fazer se R1, R2, R3, assim por diante. Agora eles podem ter o nome que você quiser. Eu estava apenas colocando 123 como um exemplo básico. Agora, embora isso declare várias variáveis do mesmo tipo de dados, você também pode dar a cada uma delas um valor inicial, se quiser. Então, depois de qualquer um deles, posso dizer iguais. E então, e eu poderia fazer isso para cada um. Eu poderia fazer isso por apenas um ou dois deles, etc. Portanto, essa é uma forma de declarar e inicializar várias variáveis na mesma linha desde que elas tenham o mesmo tipo de dados. E você ainda pode inicializá-los mais tarde, como fizemos acima. Então, por exemplo, aqui embaixo, posso dizer que var três é igual a quatro. Agora, eu teria declarado isso aqui e inicializado aqui embaixo. E isso seria perfeitamente válido. De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, vamos começar a trabalhar com nosso primeiro tipo de dados sendo números inteiros. Então, obrigado por assistir, e nos vemos na próxima. 9. Capítulo 3 (Variáveis): Inteiros: Neste vídeo, veremos nosso primeiro tipo de dados variável, que é o número inteiro. inteiros são usados para armazenar números inteiros, examinando os tipos de dados que podem armazenar números com pontos decimais ou números de ponto flutuante posteriormente. Muito rápidos, números inteiros não são o único tipo de dados para armazenar números inteiros. Mas porque é o que é mais comumente usado, é o que abordaremos hoje. E não se preocupe se você já precisou usar um dos outros. Eles são usados exatamente da mesma maneira. A única diferença é a faixa de valores nos quais eles podem armazenar e a quantidade de memória que eles ocupam. Então, primeiro, existem dois tipos diferentes de números inteiros. Basicamente, a única diferença entre um inteiro atribuído e um não assinado é a atribuição, aqueles que podem ficar abaixo de 0. Assim, eles podem armazenar qualquer coisa, desde esse valor negativo aqui até esse positivo aqui. E um número inteiro sem não tem permissão para ir abaixo de 0. Mas, por causa disso, ele pode armazená-lo duas vezes o valor positivo e que existe a única diferença entre os dois. Então, quando você gostaria de usar um número inteiro sem sinal? Bem, para mim, pessoalmente, se eu souber que meu número inteiro não precisa ficar abaixo de 0, sempre usarei um inteiro sem sinal para que eu tenha a maior quantidade máxima possível de positivo números disponíveis para mim sem usar nenhuma memória extra usando um tipo de dados diferente. Então, por exemplo, digamos que você criou um programa para acompanhar, digamos, um jogo de futebol e nenhum time pode ficar abaixo de 0, você também pode usar um número inteiro sem sinal. Então, vamos prosseguir e criar nossa primeira variável do tipo de dados inteiro. Então, se você se lembrar, a sintaxe para criar uma variável é a seguinte. Primeiro, vamos começar com o tipo de dados. Nesse caso, diremos em letras minúsculas para afirmar que queremos criar um número inteiro seguido pelo nome. Neste exemplo, vamos seguir em frente e dizer idade e, em seguida, um ponto e vírgula no final. E aí está com declarada nossa primeira variável inteira. Agora, antes de usarmos essa variável, precisamos dar a ela um valor inicial. Além disso, esse é um ótimo momento para informar que todo o nosso código é lido de cima para baixo dentro de nossa função principal aqui. Portanto, não consigo inicializar a variável idade antes da declaração dela. Então, por exemplo, se aqui eu tentasse dizer que a idade é igual a 0 com um ponto e vírgula no final. Não saberia qual é a idade. Porque, como eu disse, é lido de cima para baixo. Mas se pegarmos isso e colocarmos aqui embaixo, funcionará muito bem. Portanto, lembre-se de que o código antigo é lido de cima para baixo. Então, nesta primeira linha, declaramos uma variável. E na segunda linha, inicializamos uma variável. Se você se lembrar, podemos fazer as duas coisas exatamente na mesma linha. Então, vou em frente e excluí-los rapidamente. E vamos dizer que a idade igual a 0 e depois um ponto e vírgula no final. Agora, e se quiséssemos imprimir essa variável para o usuário? Bem, basicamente fazemos isso da mesma forma que imprimimos textos para o usuário. Então, aqui embaixo, vamos dizer C0. E então o operador de inserção, seguido pelo nome da nossa variável. Lembre-se de que sempre que quisermos acessar ou editar uma variável, precisamos de um nome de usuário. Então, vamos dizer CL para imprimir algo para o usuário. Então vamos digitar H. E a capitalização, aliás, precisa ser exatamente a mesma que a que está aqui em cima. Então, se, por exemplo, eu mudei isso para a maiúscula, essa variável não é mais reconhecida. Ok? Então, como eu disse, sua capitalização na programação é muito importante. Então, se quiséssemos capitalizar aqui, também precisamos ser uma capital aqui embaixo. Agora, vamos seguir em frente e executar nosso programa. E, como você pode ver, ele imprime 0 no console. Também podemos editar o valor de uma variável depois que ela for declarada. Então, por exemplo, aqui embaixo, poderíamos dizer que a idade é igual a três. Agora, poderíamos ter feito isso assim, onde declaramos nossa variável e depois inicializamos aqui e depois a imprimimos aqui embaixo. Mas estou apenas mostrando que depois fornecer uma variável e um valor inicial, você pode editá-los mais tarde. Então, dissemos que queríamos criar um número inteiro chamado idade. Nós o definimos como igual a 0. Em seguida, referenciamos H novamente. Então, queremos que seja igual a três. Em seguida, imprimimos no console. Então eu executo um código. E aí está. Imprimimos três. Agora, se dermos uma olhada em nossa variável aqui, não é muito descritiva. Veja se ele apenas imprime o valor real de H aqui. Então, por que não adicionamos alguns textos que afetam isso. Então, aqui, escrevemos CL após o operador de inserção. Vamos colocá-lo entre aspas, seguido por outro operador de inserção antes do nome da nossa variável aqui. Então, dentro dessas aspas, diremos que sua idade é o espaço do cólon, exatamente assim. E, novamente, é muito mais fácil de ler agora. Então esta é a sua idade, são três. Agora, uma última coisa que eu quero falar com você antes de passarmos para o próximo vídeo. É porque nosso código é lido de cima para baixo. Se copiarmos o contorno aqui e o colocarmos após nossa declaração de uma variável, assim. Na verdade, podemos imprimir H duas vezes com os dois valores diferentes. Então, vamos criar uma variável inteira chamada idade e defini-la como igual a 0. E então vamos imprimi-lo aqui embaixo. Em seguida, vamos alterá-lo para três e imprimi-lo novamente. No nosso programa, você pode ver como é isso aqui. E aí está. O primeiro imprime em 0 e o segundo imprime três. E lembre-se se quisermos corrigir isso para que pareça um pouco mais limpo. No início desta aqui embaixo, podemos simplesmente dizer barra invertida, barra invertida n e código R. Crie uma linha em branco para nós. E aí está. Agora você já sabe como criar e trabalhar com números inteiros. E não se preocupe, vamos usá-los muito durante todo o curso. Então você vai ter uma tonelada de prática prática. Além disso, a forma como a apresentamos aqui, que declaramos e inicializamos uma variável na mesma linha, geralmente é considerada boa prática quando você é capaz de fazer isso. A razão para isso é porque você não quer usar uma variável antes de dar a ela um valor inicial. Ao declarar, você simplesmente fornece um valor inicial imediatamente. Você evitará problemas sérios. E por último, antes que eu esqueça isso aqui é considerado um número inteiro assinado. Esse é o tipo de número inteiro padrão. Se quiser, você pode até mesmo definir isso explicitamente como um número inteiro assinado dizendo espaço assinado e depois terminar assim. Mas isso e isso são exatamente a mesma coisa. Se você quiser criar um número inteiro sem sinal, você pode simplesmente dizer sem sinal, assim. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 10. Capítulo 3 (Variáveis): pontos flutuantes: Neste vídeo, falaremos sobre tipos de ponto flutuante ou números com decimais. Agora, não vamos examinar cada tipo de ponto flutuante em C plus plus. Mas vamos analisar os dois principais. E eu vou te dizer como você pode pegar o conhecimento obtido neste vídeo e aplicá-lo também a outros tipos de ponto flutuante. Então, vamos dar uma olhada nesses dois tipos principais de ponto flutuante em C plus, plus. O primeiro que temos aqui é um carro alegórico. E um flutuador pode conter aproximadamente sete dígitos significativos. Agora, se você não sabe o que são dígitos significativos e planeja trabalhar com tipos de ponto flutuante. Eu recomendo fortemente que você analise isso. No entanto, para resumir brevemente o que são. Os dígitos significativos são cada um dos dígitos de um número usado para expressá-lo com o grau de precisão exigido a partir do primeiro dígito diferente de zero. Agora, espero que isso tenha feito sentido. Caso contrário, não se preocupe, você sempre pode pesquisá-lo em outro momento e isso não afetará sua capacidade de acompanhar este curso. São realmente decodificadores em geral. No entanto, dito isso, se você planeja trabalhar com dados, isso precisa ser incrivelmente preciso, quando você planeja trabalhar com pontos decimais e valores. Eu recomendo que você analise para que você saiba o que cada um dos tipos de ponto flutuante pode armazenar com precisão. Então, nosso segundo aqui é um duplo, que pode armazenar aproximadamente 15 dígitos significativos. E a razão pela qual é chamado de duplo é porque, na verdade, ocupa o dobro do espaço na memória. E a precisão de um duplo em comparação com um flutuador também é quase o dobro. De qualquer forma, vamos dar uma olhada em como podemos criar tipos de ponto flutuante de r. Então, assim como com qualquer outra variável, vamos começar com o tipo de dados. Então, para o nosso primeiro aqui, vamos dizer float, tudo em letras minúsculas assim. Em seguida, diremos algo como altura para o nome. Então, vamos definir isso como algo como 4.3. E então vamos colocar um ponto e vírgula no final. Agora, uma coisa que eu quero mostrar aqui é que, se eu passar o mouse sobre esse valor, você pode ver que ele acredita que esse valor aqui é um duplo. E isso porque o tipo de dados de ponto flutuante padrão em C plus plus é duplo. Então, se você não estiver realmente trabalhando com um duplo, você precisa dizer explicitamente ao compilador que você pode fazer isso adicionando um sufixo específico, dependendo do tipo de ponto flutuante com o qual você deseja trabalhar. E para um flutuador, isso será minúsculo, assim mesmo. Agora, se eu passar o mouse sobre isso, você pode ver que agora é um flutuador. Tudo bem, então se você não estiver trabalhando com um duplo, precisará adicionar um sufixo base no tipo de ponto flutuante com o qual você está trabalhando. E você pode encontrar facilmente todas essas informações on-line para os diferentes tipos de ponto flutuante caso opte por acessá-las. Mas, como eu disse, para a maioria deles , serão os dois tipos que você usará. Então, vamos também criar um duplo. Então, abaixo disso, vamos dizer tipo de dados duplo. E mais uma vez, tudo estava em minúsculas. Então, para um nome, vamos definir isso igual a 5,6, algo assim. Porque o tipo de dados padrão para números de ponto flutuante é duplo. Não precisamos adicionar um sufixo. Agora, só para que você saiba, a sintaxe para criar outros tipos de ponto flutuante será exatamente a mesma desses aqui. Assim como acontece com todas as outras variáveis. Vamos começar com seu tipo de dados, seguido pelo nome da sua variável. E lembre-se, só precisamos dessas duas coisas para declarar isso. E então também podemos atribuí-lo na mesma linha, como fizemos aqui, adicionando esse sinal de igual ou o que alguns de vocês podem conhecer como operador de atribuição. E eu vou usar essas palavras de forma intercambiável. Só saiba que é a mesma coisa, seguida por um valor aqui. Então, como eu estava dizendo, poderíamos ter declarado nossas variáveis assim. Acesse-os mais tarde usando apenas o nome. E, em seguida, defina-os iguais a algo mais tarde em nosso código. Assim. Isso teria funcionado muito bem também. De qualquer forma, eu vou em frente e desfazer isso. E mais uma coisa que quero mencionar brevemente é que, diferentemente dos tipos de dados de números inteiros, os tipos ponto flutuante não podem ser assinados ou não assinados. Todos eles são apenas atribuídos, o que significa que eles podem classificar números positivos e negativos. Em seguida, vamos imprimir essas duas variáveis. Então, aqui embaixo, vamos dizer CL. Em seguida, adicionaremos outro operador de inserção e diremos em linha. Não adicione outro operador de inserção aqui e diga oi para. Assim mesmo. E agora criamos um flutuador chamado altura e atribuímos a ele um valor de 4,3. Em seguida, adicionamos o sufixo para especificar que era outro tipo de ponto flutuante diferente de um duplo, que é o padrão. Em seguida, criamos um duplo também chamado de altura dois e o definimos como igual a 5,6. E mais uma vez, um duplo não come um sufixo porque um duplo é o tipo de dados padrão para números de ponto flutuante e/ou números com decimal. Em seguida, dissemos que queremos imprimir algo. E o que quisermos imprimir, queríamos imprimir a altura de 4,3. A propósito, esse f não será impresso. Isso é apenas um sufixo para o compilador dizer explicitamente o que é esse tipo de dados. Então dissemos que queríamos ir para uma nova linha. Então, adicionamos esta linha aqui e, em nossa nova linha, imprimimos a altura de 5,6. Então, se executarmos um código, você pode ver que tudo está funcionando bem. Mais uma vez, observe que os sufixos para tipos de ponto flutuante não são impressos. Então aí está. É assim que você pode criar e trabalhar com tipos de ponto flutuante. E você também verá mais exemplos disso mais tarde no curso. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 11. Capítulo 3 (Variáveis): booleanos: Neste episódio, falaremos sobre booleanos, também conhecido como bulls, bulls eye ou um tipo de dado para armazenar valores verdadeiros ou falsos, também conhecido como ligado ou desativado ou sim ou não, ou um ou 0. Então, vamos seguir em frente e criar um exemplo de um. Por exemplo, digamos que estamos criando um programa para uma luz. Talvez queiramos armazenar uma variável para saber se essa luz está acesa ou apagada. Então, como fazemos isso? Bem, assim como com qualquer outra variável, vamos começar com seu tipo de dados. Nesse caso, vamos dizer Bool, tudo em letras minúsculas. Então vamos segui-lo com o nome. Vou chamar isso de algo como está. Em seguida, vamos definir isso como falso. A propósito, só como referência aqui em cima. Se algo é verdade em sim, você quiser chamá-lo é o mesmo que definir como igual a um, estamos dizendo que o valor é um. E se algo está errado, agora eu tenho você. É o mesmo que dizer que é 0. Então, aqui está uma bola sendo definida como falsa, assim como dizer que on é 0. E isso funcionará de qualquer maneira. De qualquer forma, eu vou em frente e nos colocar de volta. Certifique-se de que a palavra false também esteja em minúsculas. De qualquer forma, vamos colocar isso no console e ver o que acontece. Então, digamos que algo como CL esteja ativado. Incrível. Os cantores imprimirão as coisas no console durante todo o curso. Vou apenas dizer Cl, seguido pelo que imprimiremos apenas para manter as coisas funcionando e manter o diálogo um pouco mais limpo. De qualquer forma, vamos seguir em frente e executar nosso programa. Você verá que na verdade imprime 0. Porque, como eu disse, falso é o mesmo que 0 em verdadeiro e igual a um. A propósito, ele só pode conter um ou 0. Ou você pode digitar explicitamente falso ou verdadeiro em letras minúsculas, mas não pode conter outros números fora disso. Agora, na verdade, existe uma maneira de imprimi-lo como falso em vez de apenas 0. E eu vou te mostrar isso aqui em um minuto. Muito rápido. Vou seguir em frente e mudar isso para verdade. E quando eu programo novamente, você pode ver que ele imprime um. Agora, o que eu quero que vocês façam é realmente copiar o esboço do RSC aqui com um ponto e vírgula. E então, abaixo disso, vamos dizer CO. Então vamos dizer cool alpha. Em seguida, um ponto e vírgula no final. Assim mesmo. Depois de digitarmos isso, estamos realmente habilitando algo. Então, basicamente, uma vez que isso esteja ativado, sempre que imprimirmos um valor máximo, ele realmente dirá verdadeiro ou falso. Então, se colarmos nossa linha, acabamos de copiar abaixo aqui, agora ela deve dizer uma porque nosso valor é verdadeiro. E depois de ligarmos o carretel Alpha aqui, ele dirá verdade. E vamos garantir que isso esteja em uma nova linha, na nossa primeira linha aqui no final. E vamos adicionar outro operador de inserção. E diremos a linha final assim mesmo, ou final l, devo dizer. Quando executamos nosso programa. E aí está. Agora diz um e depois é verdade. E isso seria o mesmo se mudássemos isso para falso e executássemos um programa, ele será executado exatamente da mesma maneira. Ok? E o que vamos fazer é realmente copiar essa linha superior novamente com nosso enésimo vínculo aqui. Em seguida, vamos deletar essa de baixo e colá-la, essa nova, assim. Então vamos colar mais algumas vezes. E, abaixo, dirá CL, não, Alpha, tudo em letras minúsculas. Assim mesmo. Em seguida, vamos colar o esboço mais algumas vezes. Então, quando ativarmos o alfa aqui, em vez de imprimir valores booleanos como 0 ou um, ele dirá verdadeiro ou falso. E então, quando o desativarmos dizendo No Bull Alpha, que era o padrão, ele voltará a dizer 000. Então, vou fazer alguns comentários aqui. E execute nosso código. Como você pode ver, 0 na primeira vez, depois imprima em falso três vezes e depois 03 vezes. Então temos uma linha em branco porque descemos uma linha aqui. A propósito, o spool Alpha em no, alpha faz parte do namespace std. Se você quisesse dizer explicitamente isso, mais uma vez, você poderia dizer que cólon std seguido por alfa também é aceitável. Mas como já temos aqui e estamos usando esse namespace, não precisamos redefinir de onde isso vem ou dizer explicitamente de onde isso vem. Novamente, uma última coisa para finalizar o vídeo. Algo que você pode fazer em vez de apenas dizer que usará esse namespace em geral, que neste momento estamos usando para CL, N line e vamos Alpha. Você pode dizer explicitamente quais coisas você vai usar a partir desse namespace. Então, eu poderia dizer que usando std dois pontos, dois pontos em linha com um ponto e vírgula no final, assim. E então você poderia fazer o mesmo com CL e puxar o celular Alpha e notebooks. Mas vou voltar a colocar isso do jeito que era. De qualquer forma. Agora você sabe como usar e criar variáveis booleanas, e também as usaremos mais durante todo o curso. Isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 12. 11: Neste vídeo, falaremos sobre o tipo de dados char. Agora char é a abreviação de caractere e, portanto, o tipo de dados é usado para armazenar um único caractere. O intervalo para esse tipo de dados é de menos 120 2027, assinado ou de zero a 255 sem assinatura. E você pode criar uma versão assinada e não assinada da mesma forma que fizemos com a variável inteira. Agora, o tipo de dados do gráfico também pode usar valores ASC, ISI, tos e reproduzir certos personagens também. Se você quiser saber o que são, basta procurar uma referência de tabela A-S-C-I-I. É a abreviação do American Standard Code for Information Interchange. De qualquer forma, vamos criar um tipo de dados gráfico. Então, vamos dizer gráfico para dizer o tipo de dados da variável que estamos criando, assim como faríamos com qualquer outra variável. Então daremos um nome a isso. Por exemplo, chamaremos esta carta. Assim mesmo. Em seguida, vamos inicializá-lo agora também. E diremos algo como iguais. E então, em C plus plus, quando você está dando a algo o valor de um único caractere ou caractere, você deve colocá-lo entre aspas simples. E então poderíamos dizer que poderíamos fazer capitalmente se quiséssemos. Isso será impresso da mesma forma que seria se colocassemos isso entre aspas duplas, uma sobre as declarações C out. Tão gorda quanto uma capital, ela será impressa como maiúscula. E se tiver uma letra minúscula, será impressa dessa forma. Podemos ir em frente e testar isso agora. Então, aqui embaixo, estou tentando dizer que sim. Carta. Em seguida, um ponto e vírgula no final. A propósito, para aqueles que usam o Visual Studio enquanto digitavam, você pode notar essa caixa suspensa. E você pode realmente acessá-lo usando as setas para cima e para baixo e , em seguida, pressionando Enter para selecionar uma. Aqui, ele aparece automaticamente com nome da nossa variável à medida que a digitamos. E podemos pressionar Enter para preenchê-lo automaticamente. E isso se tornará cada vez mais útil, pois estávamos esgotando programas maiores e digitando um pouco. Ou se você tiver um nome de variável mais longo. De qualquer forma, vamos seguir em frente e executar nosso programa. E como você pode ver, eu erro de digitação. Você também pode imprimir um caractere aleatório A-S-C-I-I digitando um número associado a um aqui. Então, por exemplo, vou colocar apenas 25. Agora, isso não é realmente aleatório e sempre imprimirá a mesma coisa. Eu só quis dizer que não sei qual personagem isso imprimirá . Então, temos que executá-lo. E como você pode ver aqui, ele imprime uma seta para baixo. E só para provar que não é aleatório, se eu executar isso de novo, ele imprimirá uma seta para baixo toda vez. Como eu disse, você sempre pode procurar uma referência de tabela dos caracteres ASC II se quiser ver o que são e mexer com isso. Observe isso porque não inserimos um único caractere como o valor da nossa variável char aqui. Tiramos as aspas simples. Além disso, só para mostrar isso, vamos em frente e remover o valor de 25 anos. Coloque nossas aspas simples novamente. E então vou digitar um número como três e executar nosso código. Isso também funcionará. E só para mostrar isso, apenas diz antes, você pode ir em frente e fazer disso um gráfico assinado tomando seno. Lembre-se de que esse é o padrão. Então, isso e isso são exatamente o mesmo para, digamos, sem assinatura, assim. E então isso só pode ter um valor positivo. Agora, se quisermos chamá-lo novamente, você pode ver que ele ainda funciona. De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, analisaremos o tipo de dados de string usado para armazenar vários caracteres, palavras ou frases. Então, obrigado por assistir, e nos vemos na próxima. 13. Capítulo 3 (Variáveis): cordas: Neste episódio, falaremos sobre sequências de caracteres, que é um tipo de dados para conter uma série de caracteres ou uma sequência de caracteres. Então, basicamente, sempre que você quiser armazenar uma série de texto ou números maiores que um único caractere, você deve usar uma string. Também incluiremos a string do arquivo de cabeçalho. Então, abaixo, isso copiará o que está acima. Então, digamos que a hashtag inclua o símbolo menor que. Vamos dizer string, seguida pelo símbolo maior que. E aí está. Agora temos acesso a todo o código desse arquivo. Além disso, para aqueles que usam o Visual Studio, você pode clicar com o botão direito do mouse sobre isso e ir até um documento de referência. E você pode realmente ver o código dentro desse arquivo. Mas para a maioria de vocês e para mim, isso não é muito importante. Mas para aqueles que podem acabar precisando ou estão apenas curiosos, há uma maneira de seguir em frente e ver isso. Então, como criamos uma string? Bem, assim como qualquer outra variável. Então, vamos fazer uma string, tipo de dados e tudo em minúsculas. Então vamos dar um nome a ele. Então, vamos chamar esse nome, por exemplo. Então vamos em frente e definiremos que é igual a John Doe. Lembre-se de que, sempre que estivermos trabalhando com uma série de textos, usaremos aspas duplas. E quando estamos trabalhando com apenas um único caractere, usaremos as aspas simples. Como queremos armazenar uma sequência de caracteres, usaremos aspas duplas. E diremos John, assim mesmo. E se quisermos imprimir isso, podemos simplesmente dizer C out. E se executarmos nosso programa, você pode ver que diz John Doe. E, a propósito, uma string, junto com muitas outras coisas que usamos e que usaremos no futuro, fazem parte desse namespace std. Você pode defini-lo explicitamente lá, se quiser. Você pode até ver que, se eu passar o mouse sobre isso no Visual Studio, isso me avisa que faz parte desse namespace. Mas no restante do curso, vou deixar isso aqui para que qualquer coisa que faça parte disso, eu não precise mencioná-la explicitamente. Agora, bem rápido, antes de terminarmos o vídeo, vamos realmente analisar algumas funções que fazem parte da classe string. Como eu disse, veremos as funções nas aulas. Mais tarde no curso. Haverá vários vídeos nele. Portanto, não se preocupe em entender o que são ou como funcionam agora. Mas eu só queria repassar alguns deles com você para que você soubesse como usá-los. E só para você ter uma ideia de que tipo de funcionalidade existe para cadeias de caracteres. Então, por exemplo, vamos limpar essa linha aqui. Então, depois de uma saída c e do operador de inserção, vamos colocar aspas duplas. E diremos que Meu nome é. Assim mesmo. Não se esqueça, precisamos adicionar outro operador de inserção para separar nossa variável dessa aqui. A propósito, essa coisa aqui entre aspas duplas, Sim, eu sei que é texto, mas também é chamada de string literal. Agora, quando executamos um programa, eles dirão Meu nome é espaço e, em seguida, o nome que inserimos. Mas vamos seguir em frente e também dar uma olhada em algumas funções da classe string. Então, bem rápido, vamos adicionar alguns comentários. Aqui. Eu vou dizer corda para mim. Aqui, eu diria. E então, abaixo, vamos dizer o tamanho do nosso nome, incluindo espaços. E então aqui embaixo, vamos dizer a versão plural. E eu vou te mostrar o porquê em apenas um minuto. Tudo bem, então o primeiro método, vamos seguir em frente e experimentar como o método de comprimento. E, como eu disse, abordaremos os métodos internos de funções mais tarde no curso. Então, por enquanto, basta acompanhar apenas para ver como eles funcionam. Então, vamos fazer é dizer nome, sendo o nome real da nossa string aqui, e depois morrer, também conhecido como operador de acesso de membro, ou símbolo de ponto final. E então vamos dizer comprimento, tudo em minúsculas, parênteses abertos e fechados e um ponto e vírgula no final. Então aqui embaixo, vamos fazer outra dizendo o nome. dieta, empurre, tudo em letras minúsculas, sublinhe para trás e, em seguida abra e feche parênteses e um ponto e vírgula no final. E então, dentro desses parênteses, nós realmente precisamos colocar um caractere. E se passarmos o mouse sobre isso, você pode ver que dentro dos parênteses diz que ele tem um valor de char. Então, vamos colocar aspas simples. E então um S Simples assim, porque estamos trabalhando apenas com um único caractere. Usamos as aspas simples. E agora o que vai imprimir é que nosso nome é John Doe. Porque foi isso que digitamos aqui. Ou o que você digitou lá será impresso. E então dirá o tamanho do nosso nome, incluindo espaços. Eu só vou fazer oito anos. Então, essa função aqui realmente adiciona um S ao final da nossa string ou qualquer letra que inserimos aqui. No entanto, isso não vai fazer nada. Então, se executarmos nosso código, ele funcionará. E como você pode ver, ele funciona exatamente como eu fazia antes. O problema é que, na verdade, estamos fazendo qualquer coisa com esses valores. Portanto, embora agora eu tenha o comprimento, não o imprimimos no console. Então, vamos em frente e fazer isso. Vamos dizer CO, seguido pelo operador de inserção e, em seguida, pelo nosso nome, comprimento do ponto. E isso vai funcionar muito bem. Então, como você pode ver, há John Doe e depois oito. E podemos seguir em frente uma nova linha proporcional dizendo como fizemos no passado. E outro operador de inserção, assim. E isso vai limpar isso imediatamente. E então aqui embaixo, podemos realmente imprimir este ano porque tudo isso está fazendo é adicionar um S ao nosso nome aqui. Então, depois disso, vamos dizer CL para criar uma nova linha. E então imprimiremos nosso nome. Certifique-se de colocar um ponto e vírgula no final. E executaremos nosso código. Agora diz Meu nome é John Doe. Imprimimos o tamanho do nosso nome, pois é isso que essa função retorna aqui como esse valor. E somos capazes de colocar esse valor aqui e em nossa declaração de c out. E então aqui, testamos outra função que fazia parte da classe string, que nos permite adicionar um caractere ao final da nossa string. Então, em vez de John Doe , diz John Dos. E tínhamos uma impressão impressa em uma linha separada. Assim. E como eu disse, não se preocupe em entender tudo isso agora. Eu só queria te mostrar algumas das possibilidades com cordas. Mas você não vai precisar saber disso daqui para frente. E se você estiver interessado, fique à vontade para pesquisar a classe string e algumas de suas outras funções possíveis. A única coisa que você realmente precisa tirar deste vídeo é que, ao trabalhar com uma string ou um MP, insira o arquivo de cabeçalho da string usando essa instrução include na parte superior. Em seguida, criamos uma string da mesma fizemos com qualquer outro tipo de variável, exceto que especificamos que era uma string e não era um número inteiro ou algo parecido. Em seguida, nós o usamos da mesma forma que faríamos com qualquer outra variável ao imprimi-lo. E enquanto estamos aqui, quero mostrar que, se tentarmos digitar um valor diferente, como 54 ou algo parecido, receberemos esse erro imediatamente. E isso nos dirá que isso não é adequado para esse tipo de dados. Portanto, é bom notar que isso não vai deixar você errar. Se você tentar inserir o tipo de dados errado. Você saberá imediatamente que está incorreto, pelo menos quando se trata de algo tão drasticamente diferente quanto cadeias de caracteres e números inteiros. E o que quero dizer com isso, vamos entrar em um vídeo futuro aqui, mas só queria mostrar isso de qualquer maneira, então é isso para este vídeo. E de agora em diante até o resto do curso, na verdade, vamos deixar essa declaração de inclusão para o arquivo de string. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 14. Capítulo 3 (Variáveis): Constantes: Neste vídeo, falaremos sobre constantes. Agora, uma constante é basicamente apenas uma variável. Você nunca quer mudar. E você pode estar se perguntando, por que eu faria isso? Bem, o motivo é que, quando se trata de programação, você quer fazer tudo o que puder para garantir que nada dê errado com seu código, tendo em mente o erro humano. Então, por exemplo, digamos que você estivesse fazendo um programa às quatro horas e quisesse que o relógio soubesse que há 60 minutos em uma hora. E isso nunca, nunca iria mudar. Você gostaria de torná-la uma variável constante , de forma que não houvesse nenhuma maneira possível de ser confundida e mexer com o resto do seu código no futuro. Então, o que vamos fazer é dizer const, que é uma palavra-chave para representar que queremos criar uma variável constante que um CON seja t. E então vamos dizer, e então diremos minutos por hora para o nome lá. E então vamos definir isso como igual a 60 e colocar um ponto e vírgula no final. Aí está você. Agora criamos uma variável constante que não pode ser alterada. Você pode fazer isso com todos os diferentes tipos de variáveis. Bem, você precisa colocar essa palavra-chave constante antes do tipo de dados. Então, basicamente, a sintaxe ou a regra para criar uma variável constante. E você vai dizer const, seguido pelo tipo de dados, seguido pelo nome e depois pela atribuição da variável. Então, coloque-os no operador de atribuição, seguido pelo valor. Agora, uma coisa a observar com as constantes é que não podemos simplesmente declarar isso assim. E depois, digamos que minutos por hora são iguais a dez. Por exemplo. Se eu passar o mouse sobre o ponto e vírgula aqui, você pode ver por que isso acontece. Essa é a variável const. Minutos por hora exigem um inicializador. Se você vai criar uma variável constante que você nunca quer mudar. Você precisa inicializá-lo e dar ele o valor que você deseja que permaneça permanente, certo, ao declarar a variável. Portanto, diferentemente das variáveis normais, você não pode declarar uma variável constante e inicializá-la posteriormente. Isso é tudo que eu tenho que estar exatamente na mesma linha. Então, diremos que const int minutos por hora é igual a 60, sem mais nem menos. E só para mostrar que não podemos mudar isso mais tarde. Agora, eu sei que não parece muito importante agora. Mas quando você começa a trabalhar com programas cada vez maiores que têm várias linhas de código e podem ter várias páginas. Você quer ter certeza de que não há uma maneira possível. Assim, os minutos por hora podem ser alterados porque precisam ser 60. E especialmente se estivermos fazendo um relógio, certo, se isso estiver com um único dígito de diferença até o final de um mês ou um ano. Quem quer que seja esse relógio, vai ficar confuso, certo? Então, queremos apenas garantir que seja o mais difícil possível difícil possível nosso código seja usado incorretamente. E mesmo que o programa em si não faça nada, você não manda ele fazer. Você quer explicar o erro humano? Além disso, não é tão difícil simplesmente adicionar essas palavras-chave rápidas e garantir que esse valor seja permanente. E só para te mostrar isso, se eu dissesse minutos, nosso aqui embaixo, e então tentasse igualá-lo a algo como dez. Receberei um erro imediato dizendo que esse não é um valor modificável porque é um valor constante. Ao passo que, se eu removesse isso, não é mais constante. Eu posso mudar para o que eu quiser. Então eu vou colocar isso de volta. E por causa da forma como as constantes funcionam e por causa da forma como o código é lido de cima para baixo, mesmo que eu tivesse várias linhas que ainda não mexessem no meu código. Assim que eu colocar essa palavra-chave constante lá, vai fazer com que qualquer coisa que tente ajustar esse valor apareça como um erro, me avisando que isso não pode ser feito. Então, se havia algo que estava mexendo com isso antes de inserir essa palavra-chave const, eu facilmente me daria acesso a qualquer coisa. Estava tentando mexer com esse valor. E uma última coisa antes de terminarmos este vídeo, eu só quero mostrar que, embora esse valor seja constante e que não possamos alterá-lo, ainda temos acesso ao valor é considerado uma leitura único valor. Você pode lê-lo, mas não pode escrever nele, não pode mexer com ele. Então, se dissermos CL minutos por hora e depois executarmos nosso código, você pode ver que ainda podemos coletar esse valor. Ainda podemos dizer que são 60, mas simplesmente não podemos mudar isso. E aí está. Agora você sabe tudo o que há para saber sobre constantes e programação. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 15. Capítulo 4 (entrada de usuários): entrada de usuários de Cin: Neste vídeo, finalmente vou mostrar como podemos realmente receber informações do usuário, em vez de simplesmente enviá-las para ele. Então, por exemplo, vamos pedir algumas informações diferentes do usuário e depois imprimi-las novamente no console. Então, bem rápido, vou acrescentar alguns comentários. Então, perguntaremos o primeiro nome deles. Em seguida, perguntaremos o sobrenome deles. E, por fim, perguntaremos a idade deles. Então vamos imprimir tudo isso de volta para eles. Esse é apenas um exemplo rápido do uso de comentários para tornar o código mais legível. Mas quando você realmente começa a escrever programas cada vez maiores, eu definitivamente recomendaria entrar em muito mais detalhes e realmente detalhar o que cada linha de código, onde cada a função está sendo executada quando chegamos a esse ponto. Porque quando você volta e olha seu código, seja em dias, semanas, meses ou até anos depois, ou alguém que nunca viu seu código antes, ele dá uma olhada nele. Será muito mais fácil descobrir o que está acontecendo aqui no topo. Vamos prosseguir e criar algumas variáveis para armazenar suas informações. Então, primeiro, vamos criar uma string para armazenar o FirstName. Então, vamos dizer o primeiro nome da string. Então vamos colocar um ponto e vírgula aqui no final. Então, abaixo disso, diremos string LastName. E abaixo disso, vamos seguir em frente e dizer idade. Assim mesmo. Criamos três variáveis e acabamos de declará-las. Não fornecemos esses e o valor inicial. Então, embora pudéssemos colocar um valor inicial para cada um deles, vou continuar e deixá-los em branco apenas para mostrar que podemos fazer com que o usuário insira um valor inicial em vez de inserindo um valor inicial e apenas permitindo que eles o alterem. Aqui, vamos seguir em frente e dizer CL. E então, entre aspas, dirá digite seu nome. Espaço do cólon. Assim mesmo. Eu não coloco um ponto e vírgula no final aqui. E, abaixo, vamos realmente coletar essas informações do usuário. E para fazer isso, vamos seguir em frente e dizer c n. Em seguida, o símbolo maior que duas vezes, seguido pelo nome da nossa variável, primeiro nome e, em seguida, um ponto e vírgula no final, exatamente assim. Já aqui dissemos c para enviar informações para o usuário. Vamos dizer C N para receber de volta a entrada do usuário. E também, em vez do operador de escuta, isso inserirá algo no programa ou no console. Nesse caso, usamos o operador de extração para extrair algo do nosso programa para o nosso código aqui. Portanto, os dois símbolos menores que como operador de inserção e os dois maiores que símbolos são o operador de extração. E em vez de gerar informações, estávamos obtendo informações. Agora, pessoalmente, gosto de pensar nesses operadores de inserção e extração como setas. E imagine que meu programa está aqui em algum lugar. Então, estou enviando informações para o meu programa e inserindo de volta dessa maneira onde meu código está. Então, essa é uma maneira de ver isso, se isso ajuda você. Ótimo. Então, neste momento, se executamos nosso programa, ele vai dizer digite seu primeiro nome. Nosso cursor no console vai parar aqui. E eles podem digitar seu primeiro nome. E então, quando o usuário pressiona Enter, ele realmente coloca o texto no programa. Então, na verdade, recuperamos as informações. E isso é mais ou menos o mesmo com nosso método get aqui embaixo. E dessa forma, confie ou pressione Enter. Depois que o usuário pressiona Enter, podemos realmente recuperar as informações dele. E é aí que tudo é executado. Então, aqui dizemos que digite seu primeiro nome. Eles podem digitar o que quiserem e pressionar Enter. E essa informação ou sequência de caracteres será armazenada aqui mesmo em nossa string FirstName. Mas ainda precisamos digitá-lo novamente para o usuário ou fazer algo com ele. Caso contrário, ele ficará aqui na variável e nunca o usamos de verdade. E vai fazer isso aqui em um momento. Mas primeiro, vamos criar uma linha em branco. Então, vamos apenas dizer CO. E assim mesmo, vamos copiar e colar isso abaixo aqui embaixo. Como vamos fazer a mesma coisa para obter o sobrenome deles, exceto em vez de FirstName, vamos dizer LastName, que é o nome da nossa outra variável. E aqui diremos que digite seu sobrenome. Então, só para que todos os nossos textos não fiquem agrupados. Vamos adicionar outra linha em branco. Então eu não desfiz isso. Vou colocar outro operador de inserção e dizer online. E eu farei o mesmo. Então, vamos copiar tudo isso de novo e colar aqui embaixo. Em seguida, diremos que digite sua idade. Em seguida, as informações que eles digitam. Queríamos entrar na nossa era. Tudo bem, e certifique-se de que, quando chegarmos a essa parte um programa, você realmente digite um número inteiro. Porque, no momento, não temos como verificar se eles realmente colocaram um número inteiro ou uma variável inteira só pode conter um número inteiro. Portanto, para evitar problemas ou erros, basta digitar um número inteiro. Caso contrário, você sempre pode fechá-lo e executar novamente o programa. Mais adiante neste curso, na verdade, veremos como podemos verificar diferentes condições. Mas, por enquanto, vamos nos certificar de que tomaremos tudo corretamente. Então vamos imprimir seu nome completo e idade. Então, vamos em frente e dizer CL. Seu nome é espaço assim. E então adicionaremos outro operador de inserção. E diremos FirstName, seguido por outro operador de inserção, com espaço entre aspas duplas. Então, outro operador de inserção e diga, tudo bem, e logo abaixo, vamos em frente e diremos linha de ciática. Outro operador de inserção. E diremos que sua idade é o espaço do cólon, outro operador de inserção. E depois passar por menor de idade. Que ponto e vírgula no final. Deixe-me ampliar aqui para que vocês possam ter certeza de que todo o seu código corresponde ao meu. Então vamos seguir em frente e executar o programa. Então, vamos digitar o primeiro nome, digitar o que quiser e pressionar Enter. Vai pedir nosso sobrenome. Agora observe que quando pressionamos Enter depois de digitar seu nome, isso contou. Isso vai até a próxima linha. Então essa linha final aqui caiu mais uma, e a próxima caiu mais uma. Então, na verdade, há dois espaços. Então, se quisermos limpar isso, podemos simplesmente remover uma dessas n linhas de cada uma delas. Caso contrário, acho que está tudo bem do jeito que está. Eu só queria que você soubesse disso. Depois, digitando o que quiser para o sobrenome, digite novamente. Então eu vou pedir h. Vou digitar um número inteiro. Pode ser o que você quiser, realmente não importa. E aperte enter novamente. E isso encerrará o programa. E você pode estar se perguntando por que fechou imediatamente. O motivo é porque pressionamos Enter no final aqui. Na verdade, contava que , como parte do pecado, morria. Então, o que vamos fazer é copiar isso e colar mais uma vez. Então, execute o programa novamente, apenas recapitulando nossas coisas. E aí está. Então, e isso é para o primeiro nome, tipo, o que quisermos como sobrenome dela, separe todos. Quanto ao seu H, a mesma coisa. Apenas certifique-se de que seja um número inteiro, já que está sendo armazenado em um número inteiro, lembre-se de que poderíamos ter colocado isso em uma string e funcionaria bem. Em seguida, imprimimos de volta para o usuário. Seu nome é e sua idade é seguida pelo nome e idade. E só para mostrar que isso funcionaria como uma string, vou colocar uma string ali mesmo, executar o programa. E como você pode ver, funcionou muito bem. Mas eu só queria mostrar que você pode coletar diferentes tipos de variáveis do usuário. Não precisa ser uma corda. Agora, espero que você tenha aprendido algo aqui. Se você estiver confuso, eu recomendo que você volte e assista novamente ao vídeo. E se você ainda não conseguir descobrir e me avisar na seção de discussão abaixo, entrarei em contato com você assim que puder. Mas não se preocupe se você sentir que entendeu, mas ainda quer praticar um pouco mais e faremos muito com esse tipo de coisa durante todo o curso. Então, de qualquer forma, obrigado por assistir, e nos vemos na próxima. 16. Capítulo 4 (entrada de usuários): funções Getchar e Getline: Como vão as coisas, pessoal? Neste vídeo, queremos pedir ao usuário o nome completo, armazená-lo em uma variável e imprimi-lo de volta para ele. Agora, você pode estar pensando, ei, não foi isso que acabamos de fazer no último vídeo? Bem, e mais ou menos, mas neste vídeo, vamos usar alguns métodos novos. Então, eu queria ficar com algo que já era familiar para você. Vamos apresentar algo novo. Então, vamos criar uma string aqui. E vamos chamá-lo de nome completo. Assim mesmo. E nós vamos apenas declarar isso. Não vamos colocar nada. Então. Vamos pedir ao usuário o nome completo. Então vá em frente e diga C para fora. E então, entre aspas, dirá Por favor, coloque o espaço de dois pontos no final. E então aqui embaixo, vamos imprimir o nome completo deles. Não esqueça o ponto e vírgula no final. Então diga CL. E então, entre aspas, vamos colocar a barra invertida n. e diremos seu nome completo. Espaço do cólon, assim mesmo. E, em seguida, adicionaremos outro operador de inserção impresso, nome completo, o nome que eles nos deram. Agora, no último vídeo, dissemos pecado para coletar seu nome completo. Vamos seguir em frente e fazer isso de novo. Só para te mostrar uma coisa. Vocês vão simplesmente tirar isso. Então, vamos dizer cin, nome. E depois de imprimirmos o nome completo, vá em frente e coloque outra linha N aqui. Assim mesmo. E você verá por que eu coloquei isso aqui em apenas um momento. Agora, dependendo do programa que você está usando, deve haver uma maneira de executar seu código sem essencialmente depurar ou verificar erros. E no Visual Studio, você pode pressionar Control mais F5 ou simplesmente apertar essa placa vazia aqui na parte superior. E independentemente do programa que você está usando, deve haver uma opção para executar seu código sem depurar. Mas se não, você pode simplesmente pegar o código GET de Sendai. Basta copiar e colar isso algumas vezes e você terá o mesmo efeito. Talvez você precise inserir mais alguns termos, sair ou pressionar o X na parte superior do seu programa. Mas vou colocar o que eu tive durante todo o curso e executar sem depurar. E a razão para isso é um pouco mais complicada do que eu gostaria de abordar no momento. Mas, por enquanto, tente executar seu código sem depurar ou copiar e colar essa linha aqui várias vezes e você ficará bem. Então, quando executarmos nosso código, ele dirá: por favor, digite seu nome completo. Vá em frente e veja John Doe, por exemplo. E então você notará que apenas diz Meu nome completo é John. E então me pediu que pressionasse qualquer tecla para continuar. E isso é por causa do Visual Studio, pelo menos quando você executa seu código sem depurar, ele não será encerrado automaticamente. Agora, por que diz apenas John? Bem, como por causa desse objeto pecaminoso aqui que usamos para recuperar a entrada do usuário, na verdade interromperá a gravação informações assim que colocarmos esse espaço aqui. É por isso que, assim que terminamos digitar Jon, basicamente dizia, ok, eu sou apenas John, aqui para ver o nome completo. Mas e se quiséssemos coletar tudo, incluindo o espaço? Bem, podemos usar uma nova função chamada função getline. No momento, vamos comentar essa linha aqui para que ainda possamos vê-la, mas na verdade isso não afetará nosso código. Então, logo abaixo da nossa declaração cin que tínhamos, diremos getline e todos os parênteses abertos em minúsculas, seguidos por sin ou C, espaço vírgula, seguido pelo nome da nossa variável, sendo nome completo, parênteses próximos e ponto e vírgula no final. Assim mesmo. Então, agora o que estamos fazendo é inserir as informações que obtemos da nossa função getline aqui no nome completo da variável. Ao contrário de nossa última declaração aqui, que registrou informações e as colocou em uma variável até pressionarmos a barra de espaço ou a tecla enter, assim, obter a função de linha ou um método aqui coletará até pressionarmos a tecla Enter. Então, ele selecionará tudo nessa linha. Agora, executamos nosso código, podemos realmente digitar nosso nome completo. E imprimirá nosso nome completo. E então, bem rápido, tenho um último método para te mostrar. Então, vamos comentar nosso método getline que acabamos de usar. E, abaixo disso, diremos que o nome completo é igual a getchar, tudo em minúsculas, parênteses abertos e fechados e um ponto e vírgula no final. Com esse método ou função, aqui é só digitar o próximo caractere. E eu vou te mostrar como isso funciona, então vá em frente e feche seu programa sem depurar novamente. Lembre-se de que, se ele não puder fazer isso por qualquer motivo, basta copiar e colar a linha inicial do ponto sin algumas vezes. Você sempre pode sair do programa manualmente. Então, basta digitar seu nome completo, ir em frente e digitar o que quiser. Pressione Enter. Você notará que ele só precisa do primeiro caractere. Então, seguimos em frente, digite-os como quisermos. Então, quando pressionamos Enter, tudo o que digitamos é realmente colocado no programa. Ele salva apenas a primeira letra porque foi isso que dissemos que ele fizesse e a imprimímos de volta para nós. Aí está você. Sim. Toda vez que estamos trabalhando com o console, vocês podem literalmente digitar quiserem e isso não vai adiantar nada. Já que você já teve tudo o que digitou, na verdade será colocado no programa que estamos executando aqui. E então ele fará o que você mandou com essa informação. De qualquer forma, para este vídeo, eu só queria mostrar esses dois métodos extras aqui que você pode usar para obter a opinião do usuário. Agora, a função get char aqui pode não ser muito útil para você na maioria das vezes, mas definitivamente haverá várias vezes para essa função getline definitivamente seja útil. E, na verdade, existem outras maneiras de usar esse método que você pode pesquisar on-line se estiver interessado. Mas, por enquanto, esse é o básico e o mais provável de ser usado com mais frequência. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 17. Capítulo 4 (entrada de usuários): string a int: Neste vídeo, mostrarei como podemos converter uma string em um número e como podemos fazer o oposto de converter um número em uma string. Então, vamos entrar nisso. Agora, aqui, tenho alguns métodos diferentes que você pode usar. Apenas mostre que há um punhado deles por aí. E, na verdade, há muito mais do que apenas os três que eu listei, mas usaremos esse primeiro como exemplo. Então, vamos continuar e criar um número inteiro. Vamos dizer que o número é igual a cinco. Então, abaixo, você realmente criará uma variável de string. Vamos dizer string, número escrito é igual. Vamos colocar esse dez dentro das aspas duplas porque queremos que seja uma string. Então, aqui embaixo , vamos imprimir nosso número inteiro. Então, vamos dizer C out. Em seguida, abaixo disso, criará uma linha em branco. E, abaixo disso, vamos em frente e converteremos nossa string em um número. Então, como podemos garantir que isso funcione? Primeiro, vamos dizer que o número é nosso número inteiro lá. E então vamos defini-lo como igual. Então, aqui vamos usar um novo método. Então, vamos dizer S, T, O e tudo em minúsculas entre parênteses. Vamos colocar o nome da nossa corda. Então, vamos dizer número vermelho, fechar os parênteses e colocar um ponto e vírgula no final. Portanto, certifique-se de que combina com o meu aqui. Então, primeiro criamos um número inteiro chamado números para que o cinco. Em seguida, criamos uma string chamada número aleatório e a configuramos uma string que contém apenas o número dez , nada extra. E então, abaixo disso, imprimimos o número, pulamos a linha ou descemos uma linha, devo dizer. E então definimos um número igual ao número escrito, que deve ser dez. E fizemos isso com esse método chamado de S, muito curto para string para inteiro, certo? Porque queremos converter essa string em um número inteiro para que possamos definir nosso inteiro atual igual a ele. Em seguida, criaremos outra linha em branco. E também imprimiremos o número novamente. A propósito, no restante do curso, eu recomendo apenas executar seu código sem depurá-lo. E se você estiver no Visual Studio, lembre-se de que você pode simplesmente segurar a tecla Control e pressionar F5. E como você pode ver, dissemos cinco, depois dez. Mesmo que tenhamos impresso o número inteiro duas vezes. Porque podemos converter esse número aqui dentro da nossa string em um número inteiro. A propósito, para aqueles que estão no Visual Studio, se manter o controle e encabeçar cinco é uma dor, você sempre pode apertar esse botão na parte superior. Ou se você realmente quiser, você pode ir para Ferramentas, Opções, ir até a depuração. Geral. Bem na parte inferior. Basta desmarcar a caixa que marcamos novamente no segundo vídeo. Isso fecha automaticamente o console quando a depuração é interrompida. Caso contrário, você sempre pode deixá-lo marcado e terá as duas opções disponíveis a qualquer momento. E isso é útil porque quando você realmente envia seu programa para alguém usar, ele não vai ficar aberto como no Visual Studio. Portanto, é bom poder ter as duas opções. Mas enquanto você está apenas programando , praticando e aprendendo, você pode simplesmente desmarcar isso e clicar em OK. E vamos esperar que você pressione uma tecla antes de fechar o programa, mesmo quando você o executa com depuração ativada, apenas pressionando F5. E você pode ir em frente e remover esse ponto pecaminoso se decidir fazer isso , pois eu realmente só os tenho aqui para pessoas que possam precisar deles. Agora, a próxima coisa que vamos fazer é converter um número em uma string. Bem, como fazemos isso? Então, em vez de converter número cinco aqui para esse número sendo dez, convertendo nossa string em um final, como fizemos aqui em cima. Vamos seguir em frente e comentar essas duas linhas. A propósito, para aqueles que estão no Visual Studio, você pode simplesmente destacar as linhas que deseja comentar e, em seguida, clicar neste botão aqui na parte superior e sair todas as linhas que o selecionam. E se você quiser descomentá-los, basta clicar no botão ao lado , sem mais nem menos. Então, vamos em frente e comentá-los. Então, agora, criamos duas variáveis e imprimimos o número. E então nós descemos uma linha. Então, aqui embaixo, vamos realmente fazer o oposto. Vamos converter nosso número de 5 anos em uma string. Então, para fazer isso, vamos dizer que o número da Grã-Bretanha é nosso nome de string aqui. É igual a todas as letras minúsculas, seqüência de sublinhado, tudo em minúsculas novamente. E então, entre parênteses, vamos colocar nosso número inteiro. Então, vamos apenas dizer número, seguido por parênteses próximos e um ponto e vírgula no final. Então, o que isso vai fazer? Começará a ler o número sendo nossa string igual ao valor da string do nosso número. Então, basicamente, o oposto do que fizemos aqui em cima, mas, em vez disso, usamos o método de duas cadeias de caracteres que converte este ano em uma string. Agora, tudo o que precisamos fazer é imprimir isso para que possamos realmente ver o resultado disso. Então, vamos dizer C out. E então o número escrito. Quando nosso programa reimprime agora cinco duas vezes, uma sendo de nossa variável inteira real sendo número, e outra sendo de nossa string, que agora é igual a cinco, já que é a isso que o número era igual. Bem, agora você sabe como converter uma string um inteiro e como converter um inteiro em uma string. E os casos de uso para isso se tornarão mais aparentes à medida que continuarmos com o curso e começarmos a entrar em códigos mais complicados. De qualquer forma, isso é tudo neste vídeo e no próximo vídeo, vamos começar a trabalhar com uma aritmética básica. Então, obrigado por assistir, e nos vemos na próxima. 18. Capítulo 5 (Operadores): Aritmética básica: Neste vídeo, abordaremos uma aritmética básica em programação. Então, a primeira coisa que vamos fazer é criar algumas variáveis inteiras. Então, vamos em frente e digamos que int num um é igual a cinco. Então, abaixo disso, diremos que int num dois é igual a dez. Então, bem, vamos criar outra variável inteira, que conterá o resultado de qualquer matemática que fizermos no futuro aqui. Então, eu vou dizer que o resultado é igual, e vamos defini-lo como 0 por enquanto. Lembre-se de que poderíamos simplesmente declará-lo se quiséssemos, mas vamos prosseguir e inicializá-lo. Então, aqui embaixo, vamos fazer algumas contas. Agora, a matemática em C plus plus funciona da mesma maneira. Não se relaciona. Para multiplicação. Na verdade, você vai usar a divisão do símbolo do asterisco. Você usará uma barra, adição, sinal de mais e subtração. O símbolo de subtração, também C mais mais, segue a mesma ordem de operações com a qual você está acostumado quando se trata dessas quatro aqui. E também existem alguns outros símbolos e coisas diferentes que você pode fazer que também se enquadram na tabela de ordem das operações. Então, se você planeja fazer algo sério com matemática na programação, eu recomendo dar uma olhada no C plus, além de qualquer tabela de matemática de operações e ver como tudo isso funciona. De qualquer forma, vamos seguir em frente e fazer algumas adições básicas aqui. Então, diremos que o resultado é igual a num um mais número dois. A propósito, você pode até mesmo definir uma variável igual a outra variável. Então, se eu disser que o resultado é igual a num, um, o resultado seria igual a cinco. Mas estamos aqui, vamos dizer num um mais número dois, que deve ser 15. Podemos testar isso dizendo c out. Execute nosso código. E aí está. E só para mostrar que isso segue a ordem correta das operações gerais, e digamos, multiplique aqui mesmo depois de um M dois por dois novamente. Então, se isso fosse lido da esquerda para a direita, seria cinco mais dez, o que seria 15 vezes dez, se você quiser 50. Mas como isso segue a mesma ordem de operações, estamos acostumados, ele fará a multiplicação primeiro. Então, na verdade, será dez vezes dez, o que é 100, mais cinco, que é 105. E se executarmos nosso programa aqui, você pode ver que esse é o caso. E caso você esteja curioso sobre a matemática aqui, você pode dizer que resultado é igual a tempos de resultado. Até agora, vai dizer que o resultado é 0. Queremos definir igual a número um , número dois, que sabemos que será 15. Então aqui embaixo vamos dizer resultado, que é 15 igual ao resultado sendo 15 novamente vezes num a dez, deve acabar em 1 quinto. Em seguida, vamos imprimi-lo. E aí está. Então aí está. Agora você já sabe como fazer algumas contas básicas em C plus plus. E se quiséssemos, poderíamos até pedir esses números ao usuário. Por exemplo, em vez de configurá-los aqui, posso ir em frente e removê-los. E vamos deixar nosso resultado igual a 0 para começar. E então, aqui embaixo, diremos resultado é igual a num1 mais num2. Mas logo antes disso, vamos sair. Então, entre aspas, dirá tipo. Pessoa número dois. Foi adicionado o fluxo que dirá C out novamente. Segundo pedido adicionado. E então, entre eles, teremos que dizer CAN um para o primeiro a chegar. E, abaixo disso, declaramos duas variáveis inteiras. Declaramos e inicializamos uma variável de resultado. Em seguida, imprimimos e queremos que o usuário digite o primeiro número a ser adicionado. E, na verdade, vou colocar um espaço de dois pontos aqui só para fazer com que pareça um pouco melhor do que quando eles pegam o primeiro número e pressionam Enter. Vai pedir a eles um segundo número. E se quisermos, podemos seguir em frente e colocar uma nova linha assim. Em seguida, eles podem digitar o segundo número e pressionar Enter. E então, aqui embaixo, ele vai automaticamente somar esses dois números. E na parte inferior, podemos dizer algo assim. Corte o C e depois aspas e coloque uma nova linha. Diremos que o resultado é um espaço de dois pontos como esse. Verifique se eles estão com ponto e vírgula no final. E antes que eu esqueça, vou colocar esse cólon e o espaço aqui. Depois de solicitarmos o segundo número também, executaremos nosso código. Lembre-se de fazer isso sem depurar erros. Não quero dizer apenas 105 ou você pode digitar os números que quiser para dar o resultado aqui. Então, para mim, diz que meu resultado foi 15. E lá vamos nós. E então, se eu quisesse limpar isso ainda mais, porque meu advogado pediu que eu apertasse um botão antes de continuar. Eu poderia simplesmente mostrar uma nova linha no final aqui, assim. E isso vai funcionar muito bem. E aí está. Parece muito bom. De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, mostrarei alguns operadores extras. Então, obrigado por assistir, e nos vemos na próxima. 19. Capítulo 5 (Operadores): incremento e Decrement: Neste vídeo, mostrarei alguns novos operadores que você talvez não tenha visto antes. Mas eles são bastante comuns em linguagens de programação. Portanto, o primeiro é o operador de incremento sendo dois símbolos adicionais, basta adicionar um ao que você está usando. No operador de decréscimo, que é simplesmente subtrair um do que você está usando. Então, deixe-me seguir em frente e mostrar como eles funcionam. Primeiro, vamos criar uma variável inteira. Então, vamos dizer que int num um é igual a cinco. Então, abaixo disso, seguiremos em frente e realmente usaremos esses operadores. Então, por exemplo, vamos seguir em frente e usar o operador de incremento. Para fazer isso. Vamos dizer um mais, mais e depois um ponto e vírgula no final. E aí está. Agora vai adicionar um ao número um e os ombros a você. Vamos imprimir o número um. Num, faça isso e execute nosso programa. Como você pode ver, diz sexo. E se fizéssemos o oposto aqui e disséssemos menos, menos e executássemos nosso programa novamente. Por enquanto, dirá que é exatamente o mesmo que se tivéssemos feito o seguinte. Então, vou comentar isso rapidamente e dizer número um. Num menos um. Assim mesmo. E quando eu for, como você pode ver, novamente, se eu colocasse um sinal positivo, eu teria enviado seis. Então, como você pode ver, é exatamente a mesma coisa. É muito mais rápido e muito limpo dizer num um menos, menos ou mais, mais. Então, fazer num um é igual 91 e depois mais ou menos e depois um. E muitas vezes você precisará simplesmente subtrair ou adicionar um a algo, especialmente na programação. Então, esse é outro motivo pelo qual isso está disponível para você e por que é uma boa ferramenta. Agora, mais uma coisa que quero mostrar é que você pode realmente colocar esses operadores no outro lado da variável e isso realmente faz algo diferente. Então, se formos em frente e apagarmos a linha que acabamos de criar e, em seguida, descomentarmos ou anularmos um com o operador de decréscimo. Se eu colocar o menos, o menos do outro lado ou o operador de decréscimo e executar nosso código, ele imprimirá a mesma coisa. Você pode pensar, oh, bem, funciona da mesma maneira então, mas na verdade é que algo diferente está acontecendo aqui. E eu posso te mostrar o que é isso. Então, vamos prosseguir e criar outra variável. Vamos chamar isso de número dois e defini-lo igual a. Além disso. Só para mostrar algo rápido enquanto estamos aqui, caso você veja em outro lugar, você pode fazer o seguinte. Em vez de dizer int num dois é igual a cinco, você poderia simplesmente dizer int num dois, e então entre parênteses, você poderia ter cinco. E isso é exatamente o mesmo. Você também pode vê-lo entre colchetes, assim. Isso também é exatamente o mesmo que se eu dissesse que número dois é igual a cinco. Eu só quero te mostrar isso, caso você veja. Mas, pessoalmente, acho que é menos elegível e não o vejo com frequência. Então, eu gosto de dizer que minha variável é igual a qualquer coisa. Ok? Então eu vou seguir em frente e dizer que número dois é igual a 0 por enquanto. Agora, aqui embaixo, se você se lembra, tínhamos r menos menos e depois número um, em vez de colocar nosso operador do outro lado. E quando executamos nosso código, ele fez exatamente a mesma coisa de antes. Subtraímos um da nossa variável num um e depois o imprimimos. Mas isso é realmente diferente. E você pode estar se perguntando: como isso é diferente? Bem, aqui embaixo, se eu disser número dois é igual a menos, menos número um, e então realmente imprimir número dois e rodarmos nosso código. Vai parecer, você já viu antes porque eu tinha quatro anos. Mas se realmente formos em frente e colocarmos isso de volta para o outro lado, você verá qual é a diferença. Então, se excluirmos isso novamente e o movermos para o outro lado onde o tínhamos originalmente e executarmos nosso código. Na verdade, vai dizer cinco. E se imprimirmos o número um aqui embaixo, vou colocar isso em uma nova linha, só para que fique um pouco mais legível. Então, se eu executar um código, você pode ver que ele será impresso por ser o número um. E então ele vai imprimir cinco sendo o número dois. Por que isso? Bem, deixa eu te contar. Então, num um menos menos subtrairá um do número um. O número um será igual ao resultado disso. Então, num um é igual a quatro, mas na verdade ele retorna o valor antes que essa operação aconteça. Então, é basicamente o mesmo que se disséssemos que número dois é igual a número um. E você pode ver isso assim: se apenas destacarmos isso até o final do nosso nome de variável num um aqui, ele basicamente diz que número dois é igual a número um. E depois essa operação acontece e imprimimos esse resultado. Mas se movermos isso para o outro lado e, em seguida, destacarmos o mesmo intervalo, estando entorpecido até o número um. Você pode ver que a operação acontece dentro disso. E a operação realmente acontece primeiro aqui. Então, agora ele vai dizer que número dois é igual a qualquer que seja o resultado dessa operação , número um ainda será subtraído. Então, vamos ver como isso parece. Então, se executarmos nosso código novamente, você pode ver que aqui dissemos que num um igual a cinco, m2 é igual a 0. E então número dois foi igual ao resultado dessa operação, que foi para número um menos um é quatro. Então, quando imprimimos o número um, ele também tem quatro porque ainda subtraímos um do número um. Então, num um agora é quatro e M2 é igual a isso para aqueles do outro lado. Mais uma vez, lembre-se de que estamos pedindo sejam iguais ao número um e que a operação ocorra depois, ok? Então aí está. Espero que agora você saiba como usar os operadores de incremento e decréscimo. E se você não entender completamente, tudo bem. Nós o usaremos novamente mais tarde durante o curso. Mas, na verdade, a única coisa que você precisa tirar disso é que o operador mais ou o operador de incremento é o mesmo que dizer num1 é igual a número um mais um. Então isso aqui, isso aqui é exatamente o mesmo. mesmo seria se eu dissesse menos menos n, menos um. No entanto, se você estiver usando isso em uma operação, então se eu quisesse dizer que num é igual a num um mais, mais, por exemplo, então num dois será igual a num um. E então essa operação acontecerá normalmente. Ou se eu colocar o sinal de mais no outro lado aqui, então o número dois será igual ao resultado dessa operação. De qualquer forma, para este vídeo, no próximo vídeo, vamos analisar um novo operador matemático chamado módulo. Então, obrigado por assistir, e nos vemos na próxima. 20. Capítulo 5 (Operadores): módulo: Neste vídeo, veremos o operador de módulo, que é o sinal de porcentagem aqui. E esse operador fornece o restante da divisão. Então, o que quero dizer com isso, bem, vamos em frente e experimentá-lo. Então, primeiro vamos criar alguns números. Então, digamos que eu sou um igual a dez. E então int num dois é igual a três. Em seguida, usaremos esse operador. Então diga núm um módulo número dois. Assim mesmo. E então precisaremos atribuir o resultado disso a algo. Então, na verdade, criaremos outro número inteiro chamado zona. Então, digamos que o resultado seja igual a 0 no momento. E então aqui embaixo, vamos definir o resultado igual a num um módulo núm dois. Então, o que isso vai fazer? Bem, ele vai pegar num um bronzeado rosa e dividi-lo por 33, entra em 103 vezes, e então há o restante de um. Então, se seguirmos em frente e executarmos nosso programa, os resultados devem ser iguais a um, mas ainda precisamos imprimi-los. Então vá em frente e diga CL, resultado. Consegui executar seu código. E aí está. Esse é o restante da nossa divisão. E se dividirmos isso e executarmos nosso programa, você pode ver que obtemos um resultado de três. E isso porque o resultado é um valor inteiro, significa que ele só contém números inteiros em três, só vai totalmente para 103 vezes. É por isso que o resultado é três. E, na verdade, falaremos um pouco mais sobre isso em um próximo vídeo aqui. De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, abordaremos alguns operadores de atribuição diferentes. Então, obrigado por assistir, e nos vemos na próxima. 21. Capítulo 5 (Operadores): atribuição: Neste vídeo, veremos alguns operadores de tarefas. Agora, no passado, se quiséssemos adicionar um número a uma variável atual, teríamos que dizer algo assim. Um, por exemplo, é igual a dez. E então, para fazer nossas contas, teríamos que dizer num é igual a num um mais cinco, por exemplo. E isso nos dará o resultado 15. Então, num, agora somos iguais 15 porque nosso operador de atribuição pega tudo do lado direito e o atribui ao que está à esquerda. É por isso que é chamado de operador de atribuição. Agora, outra coisa que podemos fazer, que é mais rápida, é a seguinte. Podemos dizer que número um mais é igual. Oi. Isso vai fazer exatamente a mesma coisa que temos aqui acima, mas é mais rápido. Então, deixe-me provar isso para você. Então dissemos que int num um é igual a dez, e então num um é igual a num um mais cinco, que deveria ser 15. Então, para ver isso, vamos em frente e dizer C para fora. E então vamos realmente seguir em frente e criar uma nova linha também. Então, abaixo, dirá que número um é igual a dez, só para voltar ao que era originalmente. E então aqui embaixo, vamos imprimi-lo novamente. Então eu vou dizer CL um. Novamente. Vá em frente e execute um programa. Então lá vamos nós. Imprimimos 15 duas vezes. Como eu disse, aqueles aqui. E isso aqui é exatamente o mesmo. É só uma abreviatura. E você pode realmente substituir esse símbolo de adição aqui por qualquer um dos nossos outros operadores. Então eu poderia dizer que menos é igual a cinco, por exemplo, eu sei que foi impresso, impresso 15 deste primeiro e depois cinco daqui embaixo. É apenas uma maneira muito mais rápida de fazer isso. E só para mostrar que ele funciona até mesmo com o operador de módulo. E quando um programa no restante de dez é dividido por cinco 0. Então, de qualquer forma, isso é tudo para este vídeo. No próximo vídeo, falaremos sobre algo chamado concatenação. Então espero ver você lá. Obrigado por assistir e nos vemos na próxima vez. 22. Capítulo 5 (Operadores): Concatenação: Neste vídeo, falaremos sobre concatenação de cadeias de caracteres. Essencialmente, o que isso diz é a capacidade de pegar duas cordas diferentes e combiná-las em uma nova corda. Então, vamos dar uma olhada em como fazer isso. Primeiro, vamos criar duas sequências de caracteres diferentes para combinar. Então, vamos dizer que string firstName é igual a, e então vá em frente e coloque o nome que você quiser. E então faremos a mesma coisa com o LastName. Então vamos seguir em frente e fazer mais uma string para um nome completo. Então, vamos dizer string para mim. E vamos apenas declarar essa em vez de inicializá-la. Assim mesmo. Então, vamos em frente e, na verdade concatenar e/ou combinar essas cadeias de caracteres. Então, vamos simplesmente dizer que o nome completo é igual ao primeiro nome, sobrenome. Tudo bem, agora se prosseguirmos e imprimirmos isso, então podemos dizer CL, nome completo. A propósito, se você estiver usando o Visual Studio e tiver algum tipo de erro de ortografia, ou apenas quiser renomear qualquer variável, basta clicar com o botão direito do mouse nela. Em seguida, clique em Renomear. E então vá em frente e coloque o novo nome aqui. Então você pode ir em frente, clicar em pré-visualizar. E isso realmente mostrará todos os lugares em que ele substituirá o nome dessa variável. E você pode percorrer seu código até aqui para ver como ele ficará e clicar em Aplicar. E aí está. Tudo bem, agora, se seguirmos em frente e executarmos nosso programa, você pode ver que ele reúne os dois nomes. E digamos que quiséssemos separá-los por um espaço. Bem, poderíamos simplesmente colocar um espaço aqui em cima e nosso nome ou sobrenome, ou podemos simplesmente jogá-lo aqui embaixo. Então, podemos ir em frente e colocar um espaço vazio como esse, colocar um outro sinal de mais como esse, e lá vamos nós. Então, como você pode ver , está impresso ou o nome completo e até mesmo em nossa string literal ali mesmo. E aí está. Essa é provavelmente a maneira mais fácil de combinar duas ou mais cordas. E lembre-se de que isso é realmente chamado de concatenação de cadeias de caracteres. E há mais uma maneira. Eu vou seguir em frente e te mostrar. Esse método é tecnicamente mais rápido que o primeiro. Mas eu não o uso com tanta frequência só porque eu pessoalmente acho isso muito mais fácil de ler e porque é mais fácil combinar mais do que apenas duas coisas. Mas eu vou seguir em frente e te mostrar isso de qualquer maneira. Também é só um aviso. Poderíamos ter feito a mesma coisa aqui quando declaramos nosso nome completo. Então, se quiséssemos, poderíamos simplesmente copiar tudo isso aqui. E então aqui em cima, poderíamos ter dito igual, colado isso no trabalho como em casa. E então eu vou executar meu código aqui só para que você possa ver que lá está. Não há diferença alguma. Então, o que faz essa outra forma à qual eu estava me referindo? Então, em vez de usar o sinal de mais para combinar dois ou mais psiquiatras, bem, podemos fazer é simplesmente excluir isso fora do nosso primeiro nome aqui, assim mesmo. E então vamos dizer apenas um ponto anexado em letras minúsculas. E então, entre parênteses, podemos simplesmente adicionar a variável ou a string que queremos combinar com isso. E mais uma nota rápida para aqueles que usam o Visual Studio, essa pequena caixa que aparece mostra o que esse método está procurando. Na verdade, você pode clicar nas setas e elas mostrarão as diferentes opções que você tem. Então, só um aviso sobre isso. De qualquer forma, vamos seguir em frente e digitar o sobrenome aqui. Assim. E o que eles vão fazer é pegar nosso primeiro nome e acrescentar o sobrenome a ele. Agora, se formos em frente e executarmos nosso código, você pode ver que ele faz exatamente a mesma coisa. No entanto, como eu disse, eu pessoalmente acho isso um pouco menos legível e mais irritante se eu quisesse adicionar mais de uma coisa, é verdade que poderíamos simplesmente colocar um espaço aqui em cima e nosso sobrenome, e isso funcionará. Mas e se estivéssemos recebendo essas informações do usuário e não digitando diretamente, seria meio estranho usá-las dessa forma. Então, vamos seguir em frente e deixar assim. E aí está. Existem duas maneiras principais de concatenar ou combinar cadeias de caracteres em C plus plus. Então, obrigado por assistir, e nos vemos na próxima. 23. Capítulo 5 (Operadores): fundição e truncação: Neste vídeo, falaremos sobre elenco e truncagem. Agora, a transmissão é basicamente pegar um tipo de dados e convertê-lo em outro. E truncar é basicamente cortar a ponta de algo. E eu vou te mostrar o que quero dizer com isso aqui em apenas um segundo. Ok, então primeiro, vamos dar uma olhada no truncamento. Então, vamos apenas criar um fluxo básico, digamos que float num1 é igual a 5, e então digitaremos qualquer número decimal que você quiser. E então Dumbo isso. Vamos seguir em frente e dizer int num dois e defini-lo igual ao número um. Além disso, não se esqueça de colocar um F no final daqui, valor flutuante aqui, para que você diga ao nosso programa aqui que isso é na verdade um flutuador e não um duplo. Tudo bem, então agora se irmos em frente e imprimirmos o número dois, na verdade só vai imprimir cinco. E eu vou te mostrar isso agora. Então, como você pode ver, ele acabou de imprimir cinco. E você pode estar pensando que esse número está apenas sendo arredondado para baixo, mas vou te mostrar agora que esse não é o caso. Então, mesmo se eu colocasse algo como 5.99999 e execute nosso código novamente. Ainda vai dizer apenas cinco. E isso porque um valor inteiro não pode conter nenhuma precisão após um ponto decimal, certo? Ele contém apenas números inteiros. E o que realmente acontece em C mais mais isso, vai apenas truncar tudo depois do ponto decimal. Como eu disse no início do vídeo, truncar significa simplesmente cortar alguma coisa. Então, basicamente, qualquer número que você tenha que você converta em um número inteiro, e ele apenas manterá o número inteiro e ignorará o ponto decimal e tudo o passará completamente. Então, seja qual for esse número, não importa o que esteja além do ponto decimal, ele salvará o número inteiro. E esse tipo de transmissão em que convertemos um tipo de dados sendo nosso fluxo aqui para outra mão. Não precisávamos fazer nada extra. Você acabou de escrever isso da mesma forma que definiríamos qualquer variável igual a outra é chamada de conversão implícita. Ele é alterado automaticamente sem nenhum trabalho extra de nossa parte. Agora, vou mostrar um exemplo de x mais um casting em que um exemplo de x mais um casting dizemos ao nosso programa aqui que queremos mudar de um tipo de dados para outro. Especificamente, mostrarei como isso será útil. Muitas vezes, seu programa segue em frente e simplesmente algo implicitamente ou converte de um tipo de dados para outro. E vá em frente e corra normalmente. E não terá nenhum problema em fazer isso. Como eu disse, se fôssemos executar isso, tudo funcionaria bem. Sem problemas. Isso só vai cortar tudo além do ponto decimal porque um número inteiro não pode conter um número inteiro. E mesmo se fizéssemos um dobro aqui em vez de um fluxo e colocassemos um número muito longo após o ponto decimal como este, e depois mudássemos isso para um fluxo. Então, nosso número dois agora é um fluxo e vai transformar esse dobro aqui em um valor flutuante. E se executarmos nosso programa, você pode ver que ele apenas aguentou o que podia. E a maneira como ela faz essa conversão é meio confusa e nem sempre vai funcionar da maneira que aconteceu aqui, quando parece que acabou de passar de um certo ponto. Eu realmente não recomendaria fazer isso , a menos que você realmente não se importe com a precisão extra pois a forma como ela é tratada, como eu disse, pode ser bem confusa e às vezes você pode obtenha um número completamente diferente do que você esperava. Então, apenas um aviso sobre isso agora, deixe-me seguir em frente e mostrar um exemplo de quando você gostaria converter explicitamente algo em um tipo de dados diferente. Então, vamos apagar tudo isso. Vamos seguir em frente e dizer que int num um é igual a dez. E então int num dois é igual a três. Assim mesmo. Então, vamos em frente e criar um flutuador chamado resultado. Defina-o igual a num dividido por num, começando por dez, dividindo-o por três. E então, abaixo disso, vamos imprimir ou voar. Então, digamos que saia e execute um programa. Como você pode ver, ele imprimiu apenas três, embora dez dividido por três não seja exatamente três. E a razão para isso é porque os dois aqui são valores inteiros. A equação é feita com números inteiros e os inteiros não podem conter um número inteiro. Então, ele apenas nos deu três e , em seguida, definiu um resultado aqui igual a esse. Mas se quisermos obter o valor flutuante adequado dessa divisão, podemos converter explicitamente esses dois números em um flutuador. E a maneira mais fácil de fazer isso, que você verá em várias linguagens de programação baseadas na linguagem C, é a seguinte. Então, vamos colocar parênteses antes da nossa variável aqui. E então, dentro desses parênteses, vamos simplesmente colocar o tipo de dados que queremos, essa variável aqui, ou o tipo padrão aqui, para o qual nós a convertemos. Então, vamos seguir em frente e dizer flutue assim mesmo. E então aqui faremos o mesmo. Então, agora temos que flutuar variáveis, uma sendo dez e a outra sendo três, e elas serão divididas. E então o resultado dessa equação será colocado em nossa variável de resultado aqui, que será então impressa no console. Então, vamos seguir em frente e executar um programa. E, como você pode ver agora, temos o valor adequado. E isso porque a equação foi feita com flutuadores. Foi armazenado em um valor flutuante. E nosso resultado aqui foi igual a isso. Agora, e se retirássemos uma dessas transmissões de um tipo de dados para outro da nossa equação aqui e depois executássemos nosso programa novamente. Como você pode ver, ainda funcionou. E mesmo se fizéssemos isso com o outro, desse jeito e executássemos nosso programa. Eu também trabalharia. No entanto, eu não faria isso apenas para ficar do lado seguro, embora fosse uma equação bem básica e funcionasse, eu recomendaria fazer isso com os dois números. Outro exemplo disso sendo útil seria como se estivéssemos trabalhando com um tipo de dados char. Então, por exemplo, se mudarmos nosso primeiro número inteiro aqui para char num1 e definirmos como igual a dez por causa do gráfico de tabela A-S-C-I-I, isso não é realmente dez. E posso mostrar que se imprimissemos isso, se eu substituísse o número um, desse jeito e executássemos nosso programa, na verdade imprimisse uma guia radical, eu acredito. Deixe-me ir em frente e mudar isso para outro número. Um exemplo melhor aqui. Como você pode ver, ele imprimiu z e isso é por causa do gráfico de tabela sobre o qual falamos quando falamos sobre caracteres, que 122 não é realmente o valor 122. Mas se quiséssemos imprimir 122 da nossa variável char aqui, poderíamos simplesmente convertê-la aqui. Então, digamos que queremos transformar isso em um int que, mais uma vez, basta colocar entre parênteses o tipo de dados que queremos e executar nosso programa. E aí está. E agora imprimiu o valor inteiro do nosso char sendo 122. Agora, o C plus, na verdade, oferece uma maneira diferente de converter explicitamente de um tipo de dados para outro. Isso é diferente de muitas linguagens de programação baseadas na linguagem C. Então, do jeito que isso foi feito, como se tivéssemos ido em frente e removíssemos nosso custo anterior aqui e disséssemos estático, tudo sob caso, sublinhado, elenco. E então, dentro de um símbolo menor que e maior que, coloque o tipo de dados para o qual queremos converter isso. Então, por exemplo, e então a variável que queremos converter dentro dos parênteses. Assim, se executarmos nosso programa, você pode ver que isso funciona muito bem. Agora, se você quiser fazer dessa maneira, você pode. Tecnicamente, é muito mais seguro fazer isso dessa maneira. E também é mais perceptível que estamos mudando isso para um tipo de dados diferente usando a transmissão sempre. Como eu também trabalho com outras linguagens de programação C, prefiro fazer isso do outro jeito. E eu também não acho que os riscos de fazer isso sejam tão dramáticos que eu não queira digitar tudo isso toda vez que eu simplesmente quero mudar de um tipo de dados para outro. Então, pessoalmente, acho isso muito mais fácil. Acho que é muito mais limpo e muito mais rápido de digitar. E a menos que você esteja fazendo muitas conversões ou fazendo algo muito específico com isso. Como eu disse, se você estiver mais curioso sobre isso, fique à vontade para pesquisar as diferenças e por que o outro tipo está disponível no C plus plus em primeiro lugar. Mas para mim, pessoalmente e durante todo o resto deste curso, sempre que fizermos qualquer tipo de casting, vou fazer dessa maneira, porque acho muito mais fácil e pronto da mesma forma e com outras linguagens de programação C. Então, eu gosto de trabalhar apenas uma maneira, independentemente do idioma que estou usando. Então aí está. Agora você já sabe como converter de um tipo de dados para outro, explicitamente como isso. E, implicitamente, como quando tiramos de um flutuador para um número inteiro, e isso foi feito automaticamente. Não precisávamos colocar nenhuma coisa extra. Enfim. Isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 24. Capítulo 6 (condicionais): escopo: Neste vídeo, falaremos sobre variáveis, escopo de variáveis. O escopo é basicamente apenas uma seção do seu código onde uma variável pode ser acessada. E, de um modo geral, há três lugares principais onde uma variável pode ser declarada. O primeiro está dentro de uma função, como estamos fazendo, ou dentro de um bloco de código, que é representado por um colchete aberto e fechado como esse. O segundo estaria dentro da definição de um parâmetro de função e onde ele estaria localizado. Por exemplo, em nossa função principal aqui está entre esses parênteses. Agora, na verdade, abordaremos os parâmetros da função quando falarmos sobre funções e/ou métodos posteriormente no curso. E o terceiro lugar principal onde você verá uma variável declarada está totalmente fora da sua função. E isso é chamado de variável global. Então, vou mostrar isso agora e mostrar as diferenças entre uma variável declarada dentro de um bloco de código ou função aqui e uma declarada fora de uma. Agora, variáveis rápidas reais declaradas incentivo, um bloco de código ou função geralmente serão chamadas de variável local, quer, declarar isso fora disso, serão chamadas de globais variável. Então deixe-me ir em frente e te mostrar isso agora. Então, um exemplo de variável global seria se disséssemos em Louisville, simples e definíssemos como cinco. Agora, para mostrar um exemplo de uma variável local, com a qual trabalhamos durante todo o curso. Vamos apenas dizer int número local. Este também é igual a cinco. Tudo bem, então aí está. Essa aqui é uma variável global. Essa aqui embaixo é uma variável local. Então, quais são as principais diferenças entre esses dois? Bem, como essa variável está localizada fora de qualquer bloco de código, mais uma vez representada por colchetes abertos e fechados, eles podem ser acessados em qualquer lugar em nosso programa. Claro, lembre-se de que o código é lido de cima para baixo. Então, em qualquer lugar abaixo disso, poderíamos usar e acessar essa variável normalmente. Então, por exemplo, eles podem imprimi-lo aqui embaixo. E se executarmos nosso código, você verá que ele funciona muito bem. No entanto, nossa variável local não pode ser acessada fora do bloco de código em que foi criada ou acima dela, porque o código é lido de cima para baixo. Agora, atualmente, estamos trabalhando apenas com uma função sendo nossa função principal. Mas, à medida que começarmos a trabalhar com programas cada vez maiores, teremos várias funções. Então, fora apenas da nossa função principal, também teremos funções que nós mesmos criamos, por exemplo. E essa variável local não poderia ser acessada fora da nossa função principal aqui. Isso porque, por exemplo, ele não foi declarado ou criado em nenhum lugar acima disso. E por ser local e disponível apenas dentro desse bloco de código, assim que tivermos algum código fora desse bloco aqui, ele não estará mais acessível. Em termos gerais, pode muito bem não existir fora desse bloco que eu criei. E agora, só para recapitular, uma variável local como aquela criada, basicamente dentro de uma função ou dentro de um bloco de código. E uma variável global criada fora dela. E, de um modo geral, uma variável gobo estará disponível em todos os lugares do seu código. E uma variável local só estará disponível dentro do bloco em que foi criada e essa é a maneira mais fácil de pensar sobre isso. Um é local do bloco que foi criado em e quando é tão crédulo disponível em todos os lugares. De qualquer forma, se você não entender completamente esse conceito, não se preocupe com isso. Vamos trabalhar muito com isso, então você terá muitas coisas sobre práticas e exemplos. Mas eu só quero que você conheça esse conceito. De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, finalmente falaremos sobre declarações condicionais, não poderemos verificar condições diferentes, o que expandirá infinitamente as possibilidades que você tem com seu código. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 25. Capítulo 6 (condicionais): introdução de condicionais: Neste vídeo, vou dar uma breve introdução às declarações condicionais. Então, basicamente, uma declaração condicional é algo que verifica se a condição é verdadeira ou falsa. E somente se essa condição for verdadeira, bem, ele executa o bloco de código associado a ela. Lembre-se de que um bloco de código geralmente é representado por um colchete aberto e fechado. Então, por exemplo, se disséssemos que cinco é maior que um? Bem, sim, como cinco é maior que um, essa condição seria verdadeira e imprimiria Hello. No entanto, se perguntarmos se cinco é menor que um, essa condição seria falsa pois esse código seria totalmente ignorada. Então, isso é basicamente o que é uma declaração condicional e como ela funciona. Basicamente, apenas verifica se uma condição é verdadeira. E se for, ele executará o bloco de código associado a ele. Caso contrário, esse bloco de código será ignorado. Agora, trabalharemos muito com isso nos próximos vídeos e criaremos nossas próprias declarações condicionais. Então você vai ter uma tonelada de prática prática. Como eles podem ser usados para uma tonelada de coisas diferentes. Por exemplo, digamos que você esteja criando um jogo. Você pode querer ver se alguém é o primeiro jogador ou se ele pressiona o botão ou completou um determinado nível ou algo parecido. Espero que tenha sido muito fácil de entender. Se não, como eu disse, não se preocupe com isso. Você terá muita prática e mais informações e os próximos vídeos. Eu só queria fazer uma breve introdução ao conceito de declarações condicionais antes de avançarmos. Então, obrigado por assistir, e nos vemos na próxima. 26. Capítulo 6 (condicionais): operadores de relações e igualdade: Neste vídeo, examinaremos os operadores condicionais. Agora, os operadores condicionais estão disponíveis para ajudá-lo a verificar diferentes condições. Então, vamos dar uma olhada nos seis tipos diferentes. Então, o primeiro que temos aqui, que é criado usando dois sinais iguais, verifica se algo é igual a outra coisa. Então, por exemplo, cinco é igual a cinco. E é importante lembrar que isso requer dois sinais iguais, pois apenas um deles seria o operador de atribuição com o qual trabalhamos nos vídeos anteriores. Então, se você quiser verificar se algo é igual a outro, usaremos um sinal de igual duplo como esse. Agora, o abaixo disso, que usa um ponto de exclamação e, em seguida, um sinal de igual verifica se algo não é igual a outra coisa. E depois, ao lado deles, vou dar um exemplo de onde esse operador criaria uma condição real. Então, podemos dizer que cinco é igual a cinco. E então aqui embaixo, por isso não é igual a um, temos, digamos, três não é igual a cinco. E isso será verdade porque três não é igual a cinco. Então, agora é apenas um ponto de exclamação seguido por um sinal de igual. E não se preocupe, nós os usaremos nos próximos vídeos, compartilharemos e praticaremos com eles. Eu só queria dar uma introdução a cada um dos diferentes operadores condicionais. O próximo é o símbolo maior que, que tenho certeza que muitos de vocês já viram no passado, que é apenas o símbolo maior que e algo assim seria verdade. Então dez é maior do que três? Sim, sim, é. Então isso seria verdade. E então poderíamos fazer o oposto aqui embaixo. Então, digamos, três, menos de dez. E este é apenas o símbolo menor que você provavelmente já viu antes. Agora, este aqui é um pouco diferente do que você viu no passado, onde normalmente você teria a linha abaixo do símbolo maior que. Mas é bem simples. Você será apenas o símbolo maior que seguido por um sinal de igual. Vamos apenas verificar se o que está à esquerda é maior ou igual ao que está à direita. E tudo isso vai da esquerda para a direita, só para você saber. Então, por exemplo, podemos dizer que dez é maior ou igual a cinco? E isso seria verdade porque dez é maior ou igual a cinco e , portanto, poderia até ser dez, e isso também seria verdade. E então, abaixo, temos o símbolo menor ou igual a, que é apenas um símbolo menor que, seguido pelo sinal de igual aqui. E podemos ter algo como cinco, menor ou igual a dez. Agora, esses são apenas alguns exemplos muito básicos, mas observe que, em vez de incluir valores reais aqui, podemos realmente incluir variáveis que criamos, que realmente amplia as possibilidades porque então poderíamos fazer coisas com base na entrada do usuário, por exemplo. Então, esses são todos os diferentes operadores condicionais que você pode usar ao trabalhar com declarações condicionais. No próximo vídeo, examinaremos mais alguns operadores. E depois disso, vamos realmente criar nossa primeira declaração condicional. Então, obrigado por assistir, e nos vemos na próxima. 27. Capítulo 6 (condicionais): operadores lógicos: Neste vídeo, falaremos sobre os três operadores lógicos diferentes e C plus plus. E esses são mais alguns operadores que você pode usar ao trabalhar com declarações condicionais. O primeiro que temos é o operador e, que é criado usando dois símbolos n ou sinais comerciais. E do jeito que isso funciona, pois ele verificará se a expressão à esquerda e a expressão à direita são verdadeiras, e se isso for verdade, essa condição como um todo será verdadeira. Por exemplo, cinco é maior que três? Três é menos do que bom, porque ambos são verdadeiros. Isso só seria verdade se ambas as expressões fossem verdadeiras. Bem, seria uma condição verdadeira. Agora, o que está abaixo é o operador or. E isso foi criado com esses dois símbolos radicais aqui. E a forma como isso funciona é que vou apenas verificar se a expressão à esquerda ou se a expressão à direita é verdadeira, se pelo menos uma delas for verdadeira, a condição como um todo será verdadeira. Então, por exemplo, podemos dizer, cinco é maior do que três? Bem, sim, mas três é maior do que cinco? A resposta é não. Porque esse é verdadeiro. Toda essa condição é verdadeira porque só queríamos saber se uma ou outra era verdadeira. E, por fim, temos esse operador NÃO que você viu no último vídeo com o operador diferente de lá, que basicamente só retorna verdadeiro se a condição aqui for falsa. Porque cinco é menor que três, o que é falso. E estamos perguntando se isso não é verdade essencialmente, então toda essa condição seria verdadeira. Então, só para recapitular que a forma como isso funcionaria aqui como f, o que está aqui é falso. A condição como um todo retornaria verdadeira porque, essencialmente, recuperará o oposto desse operador NOT. E outra maneira de pensar sobre isso, como estamos basicamente dizendo, isso não é verdade? E por causa dessa falsidade, não é verdade. Então, de qualquer forma, isso é tudo para este vídeo. No próximo vídeo, na verdade, criaremos nossas primeiras declarações condicionais nas quais você poderá finalmente praticar com o uso desses diferentes operadores e criar declarações condicionais. Então, obrigado por assistir, e nos vemos na próxima. 28. Capítulo 6 (condicionais): se as declarações: Neste vídeo, criaremos e trabalharemos com nossa primeira declaração condicional sendo a declaração if. E essa é a declaração condicional mais básica que você verá na programação. Então, vamos dar uma olhada em como isso foi criado. Então, primeiro, vou mostrar a sintaxe de como criar uma instrução if e você pode copiá-la se quiser. Caso contrário, você pode simplesmente acompanhar. Ok, então aí está. Basicamente, vamos dizer f e depois meus parênteses. Vamos colocar uma condição de que queremos verificar se é verdade ou não. E se for verdade, faremos tudo em nosso bloco de código. E você deve ter notado que isso é basicamente o que eu mostrei quando apresentei pela primeira vez declarações condicionais para você. Então, vamos seguir em frente e criar nosso primeiro. Aqui embaixo. Vamos seguir em frente e dizer se cinco é maior que três. E então, entre colchetes aqui, vamos dizer C out. Cinco é maior que três. Parece que sim. Agora, se executarmos nosso programa, veremos que cinco são creditados do que três serão impressos no console. E isso porque nossa condição aqui era verdadeira. Então, basicamente, estamos apenas dizendo que se essa condição for verdadeira, execute esse código. E só para mostrar que isso não funcionaria se essa condição fosse falsa, vamos mudar isso. Então, vamos dizer que é cinco, menos de três. E quando nosso código novamente, e você pode ver que nada acontece. E isso porque tudo dentro desse bloco de código será totalmente ignorado. Além disso, outra coisa que você pode fazer, em vez de colocar uma expressão aqui, é simplesmente removê-la completamente. Posso apenas dizer que é verdade, e isso realmente funcionará bem. Como você pode ver, nosso código foi executado. E você também pode fazer o oposto dizendo se falso. E aí está. Agora, eu realmente não consigo pensar em um ótimo exemplo de quando você usaria isso em uma declaração if. Mas eu só quero mostrar que você pode colocar o verdadeiro ou o falso diretamente na condição. E só para mostrar um exemplo rápido de como usar o operador NOT sobre o qual falamos no último vídeo. Simplesmente colocaremos esses falsos aqui, parênteses, e depois colocaremos nosso operador NOT na parte externa. E então estamos basicamente dizendo que se o que está aqui não é verdade, o que é por causa dessa falsidade, executamos nosso código. Você verá que nosso código dentro do nosso bloco de código será executado. E eles vão. Agora, vamos seguir em frente e remover esse clique. E eu vou colocar a verdade aqui para que você saiba que nosso código deve ser executado. E, na verdade, vou remover esses colchetes encaracolados apenas para mostrar algo que você pode fazer, se quiser. Agora, se fôssemos executar isso, esse código seria executado sem nossos colchetes lá. E se eu mudasse para falso, assim. E execute nosso código novamente, isso na verdade seria ignorado. E isso porque o C plus plus realmente permite que você remova os colchetes quando você estava apenas colocando uma declaração como essa. Agora, pessoalmente, eu não recomendaria isso. Acho que é uma forma muito complicada de escrever código, mas não queria mostrar que isso é possível caso você o veja no futuro. Ok, então vamos colocar nossos colchetes volta e colocar nosso código de volta dentro. De qualquer forma, aí está. Agora você sabe como criar uma instrução if que se tornou a declaração condicional mais básica que você pode criar. Muito rápido, só para mostrar que isso funciona com variáveis. Vamos criar um casal aqui. Então, podemos dizer que um é igual a cinco. E cara, esse era o número dois igual a três. Então aqui embaixo, podemos simplesmente dizer que o número um é maior do que dois? E, como está, nosso código será executado. Agora, outra coisa que eu quero mostrar é que você poderia simplesmente colocá-los na mesma linha que eu fiz aqui em cima. Então, isso, como você pode ver, vai funcionar muito bem. E muitas vezes eu farei isso se eu tiver algo muito pequeno para colocar dentro da minha declaração if, mas normalmente falando, acho muito mais limpo ter meus colchetes encaracolados em linhas separadas. Além disso, para aqueles que usam o Visual Studio, basta digitá-lo e tocar na guia e ele o preencherá automaticamente para você. Portanto, essa é uma maneira bastante útil criar imediatamente uma declaração if. Existem outras coisas como essa que você pode ter criado automaticamente e o Visual Studio. Mas durante este curso, eu recomendaria que você simplesmente digitasse isso para praticar na prática. Agora, outra coisa que eu queria mostrar a todos vocês, porque você pode realmente colocar expressões muito maiores aqui. Então, por exemplo, poderíamos dizer num um maior do que núm dois. E diremos apenas dez maior que 35, maior que um. E como tudo isso é verdade, isso deve ser executado, executar um código. Você pode ver que funcionou muito bem. Mas se eu mudasse isso para a amostra Secretary no final aqui e executasse nosso código novamente. Porque tudo isso não era verdade. Isso não funciona. Você pode misturá-los e combiná-los com os sinais AND ou OR e nos exprimir pelo tempo que quiser. Mas quanto mais longo, maior e mais complicado você fizer isso, eu recomendaria usar parênteses, assim como você faria com expressões matemáticas para definir sua ordem de operações. Então, por exemplo, talvez eu queira colocar esses dois aqui em vez de parênteses. Então, isso foi verificado primeiro e depois verificado. Ou posso até colocar o sinal ou aqui e dizer que dez maior que 35 é maior que seis. E porque isso seria falso, então isso teria que ser verdade, porque eu gostaria de saber se isso ou tudo dentro daqui era verdade. Então, porque esse será exibido aqui, mesmo que seja falso, ou o código seria executado. Porque estamos verificando se isso é verdade ou se é verdade. Observe também que, se você não colocar nada dentro do parêntese aqui, receberá um erro. E pedirá que você coloque algum tipo de expressão. De qualquer forma, só para recapitular rapidamente, o que eu quero que vocês tirem desse vídeo é criar uma declaração if. Você só vai dizer se, em letras minúsculas e depois entre parênteses, você colocará uma condição para verificar se é verdade ou não. Então, dentro dos colchetes, você está esperando para colocar todo o código que deseja executar se essa condição for atendida. Então aí está. Isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 29. 28: Neste vídeo, falaremos sobre aninhamento de declarações if. Agora, o que quero dizer com isso? Bem, basicamente é apenas um a um se a declaração se aninhar ou se colocar dentro de outra. Então, vamos dar uma olhada em como isso seria. Então, primeiro, vamos criar uma declaração if básica como essa. E então criaremos outra instrução if dentro do bloco de código para essa instrução if. Assim mesmo. E então aqui embaixo, vamos mudar esse para falso, assim. E então aqui vamos em frente e dizer C para fora. E imprimiremos uma segunda declaração como essa. Então, vamos realmente copiar toda essa linha de código e colocá-la dentro da nossa primeira declaração if também. Assim, vamos mudar este para dizer primeiro. Então, basicamente, como essa primeira declaração de se vai funcionar é tão normal quanto verificar. Essa condição é verdadeira? E se for, tudo dentro desse bloco de código será executado. E se não, vai seguir em frente e ignorá-lo completamente. Então, esta segunda declaração if também verificará se a condição aqui é verdadeira. E se for, ele só executará o código dentro de seu bloco de código, estando aqui. Se for falso, o nome de bloco será totalmente ignorado. E então o resto do código da instrução da primeira etapa será executado normalmente. Porque se você é membro, código é lido de cima para baixo. Então, como eu poderia ser vermelho, ele vai verificar se essa condição é verdadeira. Se for ótimo, vai começar a ler esse código. Em seguida, ele verificará se essa condição é verdadeira. Se for L, leia todo o código dentro dele e continue. Se não for verdade, esse bloco de código será simplesmente ignorado e , em seguida, continuará normalmente. Então, se executarmos nosso código agora, ele só imprimirá primeiro a declaração if. E se o código aqui dentro também fosse verdadeiro. Então, se mudarmos isso para verdadeiro por enquanto, execute, nosso código dirá a segunda instrução if e depois a primeira declaração if. E a razão pela qual dizia segunda declaração if primeiro é porque meu código é lido de cima para baixo. Então, mesmo que essa primeira afirmação fosse verdadeira, ela ainda precisava ler se a segunda era verdadeira primeiro e fazer tudo dentro dela primeiro, se isso fosse verdade, antes de continuar aqui para mostrar. você que esse é o caso. Se eu cortasse esse código e o colocasse acima dessa primeira declaração if como essa e executasse nosso código novamente. Você pode ver que agora o fez ao contrário. Então aí está. Agora você sabe como aninhar declarações. E você pode fazer isso quantas vezes quiser. Agora, antes de terminarmos este vídeo, vamos também voltar a um tópico anterior, que foi quando falamos sobre variáveis locais e globais. Lembre-se de como eu disse que uma variável local só está disponível dentro seu escopo ou dentro do bloco de código do qual ela foi criada. Então, se criarmos uma variável global aqui em cima, vamos chamá-la de osso baixo e defini-la como igual a cinco. Então, como temos essa variável global aqui, ela está disponível em todos os lugares em seu código abaixo dela. Então, o que isso significa é que, em vez de nossa primeira declaração if, podemos dizer primeiro if. E depois disso, podemos imprimir globalmente. Vamos seguir em frente e criar uma nova linha. E então, mesmo em nossa segunda declaração if, também temos acesso ao global. Isso também funcionará. Então, se executarmos nosso código, ele dirá primeiro se a instrução cinco é nossa variável global. Segunda declaração if. E também só para mostrar que isso também é possível. E nossa variável global, poderíamos declará-la aqui e depois inicializá-la aqui embaixo. Lembre-se de que você quer ter certeza de dar um valor inicial a uma variável antes de usá-la. Então, antes de imprimirmos isso aqui, quero dizer global e, em seguida, dar a ele um valor inicial, três. E isso funcionará exatamente primeiro se a declaração três. A segunda é a declaração três. Mas agora vamos dar uma olhada em algumas variáveis locais. Então, se nos livrarmos disso, primeiro você notará que ele não sabe mais o que é global. Basta remover que eles estão de alguma forma, se criássemos uma variável dentro de nossa função principal, ela também estaria disponível em nossas duas declarações if. E isso porque, por exemplo se disséssemos número um aqui, e ele parecer igual a cinco, por exemplo, isso agora estará disponível em todos os lugares abaixo dele dentro de seu bloco de código. Então, até esse colchete encaracolado fechado aqui para esse método, neste caso, é nosso método principal. Então, só para resumir, nossa variável local estará disponível em todos os lugares abaixo dela porque código é lido de cima para baixo dentro seu escopo, sendo todo esse método aqui. Mas e se criássemos uma variável local dentro de uma dessas declarações if? Bem, só estará disponível dentro de seu quarteirão. Então, se disséssemos que número um é igual a cinco, fora desse bloco de código estar aqui embaixo, porque o bloco de código é executado daqui até aqui, não podemos mais acessá-lo. Pode muito bem simplesmente não existir. Então, número um é igual dez não funciona porque não sabemos o que é número um. É indefinido. Essa variável não existe porque seu escopo está aqui. No entanto, existiria em nossa segunda declaração if. Então, aqui, ainda poderíamos imprimir o número um porque está dentro do escopo. Então aí está. Eu só queria dar um exemplo melhor do que eu estava falando quando falamos sobre variáveis locais e globais. Então, lembre-se de que uma variável global é aquela criada fora do bloco de código em uma variável local é aquela criada dentro. Uma variável global estará disponível em todos os lugares após sua criação, uma variável local só estará disponível em todos os lugares depois de criada até o final de seu bloco de código. Então aí está. Espero que isso tenha feito sentido. Caso contrário, vá em frente e brinque um pouco com as variáveis locais e globais apenas para ver se o escopo de sua disponibilidade está disponível. De qualquer forma, neste vídeo, no próximo vídeo, daremos uma olhada em outro tipo de declaração condicional conhecida como declaração if else. Então, obrigado por assistir, e nos vemos na próxima. 30. Capítulo 6 (condicionais):: Neste vídeo, vamos dar uma olhada na declaração if else. Então, deixe-me seguir em frente e mostrar a sintaxe da declaração ou as regras de como essa declaração é criada. Então, assim como antes, você criará uma declaração IF básica em que dirá f e depois parênteses. Você colocará a condição que deseja verificar. Se for verdade, então seu bloco de código depois dele. No entanto, logo depois disso, você vai inserir a palavra-chave else, que também é toda minúscula, assim como F aqui. E logo depois de dizer o contrário, você colocará apenas mais um bloco de código sem nenhuma condição. Então, basicamente, estamos dizendo que se essa condição aqui é verdadeira, queremos fazer isso como o normal, ou você pode pensar nisso do contrário, faça isso. Então, vamos ver como isso funciona. Então, aqui embaixo, criaremos uma declaração if básica. Então, vamos dizer que se, digamos que cinco é maior que três, depois desse bloco de código, vamos dizer contrário e observar e o Visual Studio aqui, como ele destaca automaticamente os dois para me mostrar aqueles estão conectados. Você também pode simplesmente clicar em tab e isso criará automaticamente o resto para você. Caso contrário, você basicamente colocará outro suporte encaracolado aberto e fechado como este. Então, agora criamos nossa declaração FL, mas vamos dar uma olhada melhor em como isso funciona. Então, aqui, vamos ver como condição de impressão era verdadeira. Então, em nossa declaração else ou então bloco de código aqui, vamos em frente e dizer condição CL. E a razão pela qual eu fiz com que escrevêssemos isso especificamente é mostrar como isso está funcionando. Então, basicamente, vamos verificar essa condição como normal. Mas se essa condição for falsa, esse bloco de código aqui será executado em uma condição fixa é verdadeira. Esse código aqui será executado. Então, basicamente, você quer usar uma instrução if else quando quiser executar algo somente se a condição for verdadeira, mas você também deseja executar algo se a condição for falsa. E agora, se formos em frente e executarmos nosso código aqui, você verá que ele dirá que a condição era verdadeira porque cinco é maior que três. Mas se formos em frente e reverter isso agora, direi que são cinco, menos de três. E quando eles forem cortados novamente, vai dizer que a condição era falsa. Portanto, tudo no seu bloco de código F será executado se a condição for verdadeira e tudo mais. O bloco de código será executado se a condição for falsa. Eu sei que estamos colocando apenas uma declaração ou apenas um pedaço de código dentro desses blocos de código. Mas isso pode ser tão grande quanto você gostaria. Agora, alguns de vocês devem estar se perguntando, por que não pegamos isso e colocamos aqui? Bem, talvez não quiséssemos dizer que nossa condição era falsa se não fosse, certo. Então, isso só nos permite que um bloco específico de código seja executado apenas se isso for verdade em um bloco específico de código que só será executado se for falso. Então aí está. Agora você já sabe como criar uma declaração if else. No próximo vídeo, veremos algo chamado declarações do tipo “ outro se”. Então, como sempre, obrigado por assistir e nos vemos na próxima. 31. Capítulo 6 (condicionais): declarações de outros casos: Neste vídeo, vamos dar uma olhada na criação de uma declaração else em que podemos basicamente verificar se uma condição é verdadeira e, em seguida, verificar se outra ou várias outras condições são verdadeiras, então ainda podemos executar algo se nenhuma dessas condições for atendida. Então, vamos dar uma olhada em como isso funciona. Então, a sintaxe básica para isso é que criamos uma declaração if exatamente como tínhamos no passado. E se essa condição for verdadeira, esse código aqui será executado e todo o resto será ignorado até o fim. Mas podemos jogar isso fora daqui para ver se outra condição é verdadeira caso a primeira não fosse, então, se isso for verdade, somente esse código será executado e o resto será ignorado. E então ainda podemos ter outra declaração em que podemos dizer que , se nada disso fosse verdade, ainda gostaríamos de fazer isso. E aí está. Essa é a sintaxe básica de uma declaração else. Então, vamos seguir em frente e criar um dos nossos muito jovens. E só para nos divertir com isso, vamos criar um programa simples para isso também. Então, vamos dizer número um. E então, abaixo disso, vamos dizer int num dois. Então, vamos seguir em frente e realmente obter alguma opinião do usuário sobre eles. Então, diremos que mandou um golpe que dirá pecado. Então, no final de tudo isso, criaremos nossa outra declaração. Então, digamos que se um entorpecido for maior que dois, então queremos fazer o seguinte. Então diga C de um. E então, entre aspas aqui, diremos que é maior que. Em seguida, também adicionaremos. Para fazer isso. Vamos prosseguir e sublinhar. E vou colocar alguns espaços aqui, só para que pareça muito mais limpo quando for impresso. Então, abaixo disso, diremos outra coisa. E mais uma vez, tudo isso é minúsculo menor do que número dois. Então, queremos imprimir o oposto. Então diga CL num, num dois. E, abaixo disso, diremos outra coisa. E então lembre-se de que não colocamos uma condição, estamos apenas dizendo outra coisa. Quer dizer que um é igual a dois m? Assim mesmo. Basicamente, vamos pegar dois e animais de estimação e pegar uma entrada para eles um e depois colocar para o número dois. E então vamos dizer que se o entorpecimento um é maior que o número dois, então vamos imprimir um é maior que o número dois. Caso contrário, se número um for menor que número dois, então queremos imprimir que número um é menor que número dois. Caso contrário, se nenhuma delas for verdadeira, então elas devem ser iguais. Então dissemos que, senão, número um é igual a número dois. E então, se quisermos limpar isso, para que pareça um pouco melhor para o usuário ou para nós neste exemplo aqui em cima, podemos seguir em frente e fazer o seguinte. Podemos dizer C fora do número, espaço de dois pontos assim. E então vamos simplesmente copiar e colar isso abaixo da nossa declaração cin num , por exemplo, digamos tipo a, outro número. E então eu vou diminuir o zoom rapidamente para que vocês possam dar uma olhada completa no código, garantir que o seu corresponda ao meu. Em seguida, executaremos nosso código para garantir que ele esteja funcionando. E certifique-se de executá-lo sem depurar ou adicionar várias dessas linhas de entrada sem pontos. Então vá em frente e digite um número. Em seguida, para o seu segundo número, vá em frente e insira um número menor que o primeiro. E devo dizer que nosso primeiro número foi maior do que nosso segundo número. E então podemos seguir em frente e executar nosso programa novamente. Mas desta vez vamos digitar um número menor para o primeiro. E aí está tudo configurado. Nosso primeiro número foi de menos de um segundo. E se o executarmos novamente, podemos digitar dois do mesmo número exato. E deveria dizer que eles são iguais. E aí está, tudo está funcionando. E apenas uma nota rápida antes de encerrarmos o vídeo, quero que você saiba que você pode ter vários outros. Se as condições estiverem aqui dentro de sua declaração, você poderia dizer que Alice num um é igual a número dois, por exemplo, e então ter um bloco de código para isso também. E isso vai funcionar muito bem. Agora, obviamente, neste exemplo, podemos muito bem usar else. Mas você entendeu meu ponto de vista. Você pode ter quantas outras declarações ou condições eu deveria dizer quanto quiser. Além disso, você nem precisa dessa outra declaração na parte inferior. Isso é apenas algo que você pode ter, mas você pode se livrar totalmente dele pois seu código ainda será executado normalmente. Então, se eu executar meu programa, você pode ver que ele está funcionando , sem problemas. Então, quando você gostaria de usar uma declaração else if? Bem, sempre que você quiser verificar se há mais de uma condição e todas elas estão relacionadas como estão aqui. Você pode usar uma declaração else. Você pode ter quantos quiser, como eu disse. E então você ainda pode usar sua declaração else para executar um trecho de código se tudo for falso. E se eu voltar aqui para o que tínhamos, lembre-se de que assim que uma dessas condições for atendida, tudo o mais que, como parte dessa declaração, se aqui for ignorada. Se essa condição for verdadeira, ele apenas lerá o que está nesse bloco de código e, em seguida, pulará até o final aqui. Se o primeiro for falso e depois o segundo for verdadeiro, ele apenas lerá o que está nesse bloco de código e ignorará todo o resto. E então, se nada for verdade, nossa declaração else será executada se tivermos uma. Portanto, tenha cuidado com isso, mas ele é lido de cima para baixo e, em seguida, apenas a primeira afirmação que se tornar realidade importará. Então, mesmo que a afirmação esteja aqui, invertemos isso e dissemos que é maior ou igual a. E então execute nosso código, número um, eu coloquei dez. Para o número dois, eu coloquei cinco, por exemplo. E só vai imprimir, a caneta é maior que cinco e menos, porque assim que uma dessas condições for verdadeira, ela não se importa com o resto , independentemente de quantas outras afirmações você ter. Portanto, tenha cuidado com isso e certifique-se de que, se quiser verificar primeiro uma condição, tenha aquela no topo. Aí está. Espero que você tenha um bom entendimento agora de como declarações se e se mais funcionam. E se não, eu recomendo que você volte e assista novamente ao vídeo em que está tendo problemas e talvez brinque um pouco mais com apenas para entender melhor como tudo funciona. Dito isso, você os verá mais ao longo do curso. Assim, você terá uma prática prática mais natural. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 32. Capítulo 6 (condicionais): comutar as declarações: Neste vídeo, vamos dar uma olhada na criação do que é chamado de instrução switch. E o que isso faz é basicamente pegar um valor inteiro e , em seguida, executar um bloco de código com base no que é esse valor. Então, aqui, eu tenho a sintaxe básica disso para você. Então, basicamente, vamos dizer switch e tudo em minúsculas. E então, entre parênteses, vamos colocar nosso valor inteiro. E isso pode até ser o nome de uma variável que é um valor inteiro. Em seguida, teremos colchetes encaracolados abertos e fechados. E dentro disso, vamos dizer maiúsculas minúsculas, seguidas pelo número. Queremos verificar se esse é o número. Então, podemos dizer que, caso esse número seja um, queremos fazer isso. Depois disso, vamos dizer rompa com um ponto e vírgula para interromper essa seção do código. E então aqui embaixo podemos dizer caso dois, queremos fazer isso e depois terminar com isso também. E podemos continuar fazendo isso sem parar. E então também podemos ter um padrão, ou simplesmente dizemos padrão em todas as letras minúsculas seguido por dois pontos. Então poderíamos fazer isso. Então, também podemos ter uma declaração de pausa no final disso, embora esta não seja necessária. Em seguida, fechando o colchete, você pode ter apenas uma declaração de caso aqui, ou duas ou três , ou como eu disse, quantas quiser. Eu só tenho dois aqui para mostrar que podemos ter mais de um. Então, espero que isso não tenha sido muito confuso para você. Se eu fosse, vamos criar um do zero. Você pode ter uma ideia melhor de como isso funciona. Agora, bem rápido, alguns de vocês já devem ter feito a conexão de que isso é muito semelhante à nossa outra declaração. Bem, isso é porque as únicas diferenças reais aqui são que, para um, isso assume um valor inteiro. Em vez de podermos colocar em uma condição de falha nossa expressão de que queremos verificar se é verdadeira, então simplesmente fazemos algo com base no que é esse número. Então você pode ver isso como dizer f, colocando nosso número e depois outra coisa, Ceph os números, esse número é isso, e então nossa declaração else. Mas eu só quero que você saiba que uma instrução switch é mais rápida. E em muitos casos, se você está apenas tentando ver o que é um número, isso será muito mais legível. Então, vamos seguir em frente e criar um dos nossos. Então, aqui embaixo, vamos dizer que a resposta int é igual a 0. Então, abaixo disso, vamos em frente e digamos que o CEO dirá: por favor, escolha uma opção. E eu direi espaço do cólon. E então colocaremos uma linha embutida lá também. Em seguida, abaixo, criará outra declaração c out. Digamos que digite um para o botão do Menu Principal e uma linha final aqui, ou crie uma nova linha. Vou apenas dizer barra invertida n. Para esta, faremos a mesma coisa abaixo, digamos fita para quatro opções. Assim mesmo. E eu vou criar uma nova camada novamente e abaixo dela realmente criará nosso switch. Mas antes de fazer isso, vamos seguir em frente e aceitar a resposta do usuário. Então, diremos correspondência. Em seguida, a troca de credor, se você se lembrar, vamos dizer troca e tudo em minúsculas. E então, entre parênteses, colocaremos um número inteiro ou nossa variável, neste caso sendo a resposta. E depois disso, vou ter colchetes encaracolados abertos e fechados. E então, entre esses colchetes, criaremos nossos estojos. Ou o que queremos verificar para ver se nossa resposta ou nosso número inteiro aqui é igual a. Então, por exemplo, vamos dizer maiúsculas e minúsculas, a propósito, espaço um para nosso valor que queremos verificar e, em seguida, dois pontos. Depois disso, diremos o menu principal do CL. Então, vamos seguir em frente e dizer quebre tudo em minúsculas com um ponto e vírgula no final. Depois disso, criaremos outro caso para dois e diremos opções. Então diga case. Opções de SEO da Coleman. A propósito, para aqueles que usam o Visual Studio, você deve ter notado que colocará automaticamente uma segunda aspa para você. No entanto, se você acabar digitando outra citação sozinho, ela simplesmente pulará essa citação. Isso não vai causar nenhum problema. Não vai resultar em um segundo e você pode continuar digitando. Mas é bom que isso crie mudanças para você, caso você esqueça. Em seguida, colocaremos um ponto e vírgula no final e diremos pausa novamente. E, na verdade, vou colocar nosso C aqui em uma linha separada. Vamos matar. Acho que parece um pouco mais limpo. Então, aqui embaixo, se quiséssemos, poderíamos continuar usando mais caixas para verificar. Ou podemos até mesmo adicionar um padrão, se quisermos. E vamos fazer isso só por diversão. Então diga padrão. Então, diremos que CL dirá opção é, na verdade, ela seguirá em frente e dirá sua escolha. Como eu disse, você poderia adicionar outro colapso aqui. Se você escolher, alguns de vocês podem achar que parece mais simétrico ou o que você tem, mas isso não necessariamente, essencialmente, o SprayC apenas tira você dessa seção de código, pois não os segura por colchetes encaracolados, como vimos no passado. E também, embora tenhamos apenas uma linha de código e boa, e você possa ter quantas quiser, assim como qualquer outro bloco de código. Agora vou diminuir o zoom aqui rapidamente, para vocês possam ter certeza de que tudo isso foi copiado. E também cresça rapidamente para aqueles que estão se perguntando o que eram esses pequenos blocos negativos. Para aqueles que usam o Visual Studio e muitos outros programas, como isso também, você pode clicar nele e ele realmente colapsará tudo dentro do que quer que seja. Isso está em If Statements, é sobre métodos e outras coisas assim, mas ainda deixará o que é para você. E então terá até os colchetes encaracolados de três pontos aqui. E se você passar o mouse sobre isso, poderá ver qual código está sendo minimizado no momento. Agora, o código ainda funcionará. O código ainda será executado. Basicamente, é apenas minimizar. Quero dizer, você pode simplesmente clicar no botão de adição agora e minimizar isso para você. Então, se talvez você esteja trabalhando com muito código em algum momento e a tela de repente ela pareça um pouco bagunçada. Você pode simplesmente fechar isso quando terminar trabalhar com algo ou se estiver tentando trabalhar em outra coisa. De qualquer forma, pensei em te mostrar isso rápido. Enfim. Agora, se eu seguir em frente e executar nosso código, você pode ver isso. Então, vamos escolher uma opção, digite uma para mim, muitas das duas opções. Então, vamos digitar um só para ver o que funciona. Aí está você. Diz Menu Principal. E, na verdade, vou colocar uma nova linha em ambos apenas para limpar isso um pouco, ou todos eles, eu deveria dizer assim. E execute nosso código novamente. Se pegarmos dois e ele disser opções. E se executarmos mais uma vez aqui e digitarmos qualquer número inteiro fora do que criamos um caso e apertarmos Enter. Você pode ver que suas escolhas são válidas porque nenhum de nossos casos era verdadeiro. Então, como você pode ver, ele funciona de forma muito semelhante a uma instrução else if, exceto que dentro desses parênteses, você precisará de um valor inteiro. E se quiséssemos, poderíamos ter digitado um número como esse e executar nosso código. E ainda está esperando que digitemos algo para responder. Então você pode ir em frente e fazer isso. Mas, independentemente do que digitamos, vai dizer menu principal, porque o que estava em nosso switch era um. E aí está. Agora, obviamente, não há realmente uma boa razão para você fazer isso. Normalmente, você simplesmente sua variável aqui e recebe alguma entrada, pois um switch geralmente estará lá para verificar várias opções, certo? Então você vai pegar algo que pode variar. Agora eu queria avisá-los, especialmente para aqueles que podem estar vindo de outra linguagem de programação se você remover uma dessas instruções de interrupção. Então, no nosso caso um aqui, se eu for em frente e removê-lo, ele realmente executará todo esse código até chegar a outra instrução break, independentemente de nossa resposta ter sido duas. E se seguirmos em frente e executarmos nosso código aqui, você pode ver que isso é verdade. Então, se eu digitar um, por exemplo, e pressionar Enter, ele salvará o menu principal e as opções, mesmo que tenhamos digitado um. Isso porque, sem essa interrupção, ele realmente faz algo chamado fall-through, onde ele simplesmente executará e executará todo o código dentro do seu switch até atingir uma instrução break ou no final do switch. E se eu tirasse nossa outra declaração de pausa aqui, você pode ver que ela até imprimiria suas escolhas e valeria se digitássemos uma. No entanto, essa queda só começará de onde era verdade. Então, se eu digitar, se eu executar um programa aqui novamente, devo dizer Opções e, em seguida, suas escolhas e equilíbrio. Então aí está. Agora, pode haver casos em que você queira que esse outono termine. Talvez você tenha uma boa ideia onde isso será útil. E C plus plus é uma das poucas linguagens que eu conheço que permitirá que você faça isso, pelo menos por padrão. Mas, normalmente, eles provavelmente não vão querer que isso aconteça. Portanto, você quer ter certeza de lançar o intervalo após cada um deles, fora do padrão, pois ele parará automaticamente quando atingir esse colchete fechado de qualquer maneira. E, por fim, vou mostrar a vocês como isso seria. Se essa fosse outra declaração, só para mostrar as semelhanças aqui. Então, poderíamos ter dito se a resposta é igual a um e depois colocá-la em nosso código aqui fora do intervalo. E, abaixo disso, vamos definir a fonte é igual a dois. Então, abaixo disso, podemos simplesmente dizer outra coisa e colocar isso. Então, espero que você possa ver as semelhanças aqui. Como eu disse, eles basicamente funcionam da mesma maneira. No entanto, isso nos permite colocá-lo em uma condição muito maior. Queremos verificar se é verdade ou se acabou de inserir um valor inteiro. E, pessoalmente, se isso é o que você está fazendo é apenas verificar um valor inteiro e querer ver a que ele é igual. Eu acredito que isso parece muito mais limpo e também funciona mais rápido. Então aí está. Agora você já sabe como criar uma instrução switch. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 33. Capítulo 6 (condicionais): Operador ternário: Neste vídeo, vamos dar uma olhada em trabalhar com algo chamado operador ternário. E você também pode ver isso chamado de operador condicional. Portanto, a sintaxe de um operador ternário é, portanto, você terá uma condição para verificar se ela é verdadeira ou falsa. E então isso será seguido por um ponto de interrogação. Depois disso, você terá uma expressão ou um trecho de código que deseja executar. Se essa condição fosse verdadeira, seguida por dois pontos. E então uma segunda expressão ou um trecho de código que você deseja executar se essa condição for falsa. E, por fim, você vai fechar isso com um ponto e vírgula. Agora, aqui embaixo, eu já tenho um exemplo para você só para mostrar como isso funciona. E não se preocupe, vamos criar um dos nossos. Eu só queria mostrar como isso pode parecer na escrita ou no código real. Então, minha condição, essa é uma maior que cinco, seguida por um ponto de interrogação e, em seguida, minha primeira expressão, ou um trecho de código aqui. Então, nesse caso, eu disse C para “olá”, então eu estava com meu cólon. E então a segunda expressão ou pedaço de código que eu quero que ele execute se a condição for falsa. Então esse C saiu. Então, como esse não é maior que cinco, esse trecho de código será executado. Se eu executar meu programa aqui. Você pode ver que diz comprar. Mas se virarmos aqui e perguntarmos: Um é menor que cinco? Porque isso é verdade. Então, nosso primeiro trecho de código aqui, que está no lado esquerdo do nosso cólon, executará o código novamente. Você pode ver que diz Olá. Além disso, quero que você observe que eu não coloquei um ponto e vírgula após minhas aspas duplas. E isso porque esse é o fim da declaração, não isso. Tudo bem, então vamos seguir em frente e criar um dos nossos muito jovens. Então eu vou em frente e remover isso. E então vamos dizer um. E abaixo disso, diremos o número CN, certo? Então, vamos pegar um número que digitamos. E então vamos prosseguir com a operadora ternária de crédito. Então, vamos dizer num um maior que 0. E essa será nossa condição. Depois disso, colocaremos nosso ponto de interrogação e, em seguida, seguiremos com uma expressão ou um trecho de código que queremos executar se essa condição for verdadeira. Então, vamos dizer C fora, não um. Então, entre aspas aqui, vamos em frente e digamos que seja um número positivo. Em seguida, vamos continuar com dois pontos. Depois disso, vamos dizer C out novamente. Número um. E então, desta vez, diremos que é negativo. Observe que eu coloquei um espaço antes de estar em ambos porque não haverá um por padrão depois nosso número um for impresso ou houver um número inteiro lá. Agora, se executarmos o código, eu poderia dizer algo como cinco. Digamos que cinco seja um número positivo. Ok? Mas se executarmos isso de novo, e eu colocar menos cinco e no centro, eles dirão que menos cinco é um número negativo. E isso porque dissemos esse número um maior que 0. Então, se for, dissemos que queríamos imprimir num um é um número positivo. E se não fosse maior que 0, queríamos imprimir que um é um número negativo, certo? Aí está você. Essa é a maneira básica de usar um operador ternário. E muitas vezes você basicamente verá isso usado em vez de uma declaração if else. Então, vamos em frente e criar o que isso pareceria como uma declaração da FL. Poderíamos simplesmente ter dito se um fosse maior que 0. E então dentro do um impresso está um número positivo. Então, vou apenas copiar e colar isso de cima. E abaixo disso, diremos outra coisa e colaremos isso. E teremos que nos certificar de colocar um ponto e vírgula no final de nossas duas declarações C out. E aí está. É assim que poderíamos ter feito a mesma coisa com uma declaração if else. Mas há mais algumas maneiras de usarmos isso. Então, vamos dar uma olhada nisso. E eu vou remover nossa declaração de caso contrário. Agora, vamos dar uma olhada em outra forma de usar o operador ternário. Então, aqui embaixo, vamos dizer o resultado da sequência de caracteres. E definiremos isso como igual a um operador ternário. Então, aqui vamos dizer num um maior que 0, seguido por um ponto de interrogação. E então, dependendo do que isso é, queremos realmente definir nossa string igual dois é um número positivo ou um número negativo, mais ou menos como fizemos antes. Está aqui mesmo. Em seguida, siga com dois pontos e, em seguida, coloque essa outra sequência aqui. Em seguida, nosso ponto e vírgula no final. Agora criamos uma string chamada result e a definimos igual ao resultado desse operador ternário, toda essa operação aqui. Então, ele vai dizer como número um maior que 0. Se for, nossa string será igual a isso. E se não for, nossa string será igual a isso. E agora, aqui embaixo , vamos imprimir isso. Então, vamos dizer C de número um. Depois disso, eu imprimo o resultado, criarei uma nova linha como essa. Em seguida, vamos remover nossa operação ternária anterior e executar nosso código. Agora, você pode ver que funciona praticamente da mesma forma que funcionava antes, com a única diferença de que realmente usamos esse operador ternário aqui para definir algo igual a um resultado com base nisso aqui. E vamos continuar e colocar isso em uma declaração se for o caso novamente. Então, digamos que se um entorpecido for maior que 0, então queremos definir um resultado igual a esse aqui. Caso contrário, Alice definirá resultado igual a dois é um número negativo. Assim. Agora você pode usar o que quiser, o que achar preferível com sua situação atual em sua programação. Eu só queria te mostrar as diferentes maneiras pelas quais você pode usar isso. E, na verdade, há uma última maneira pela vamos abordar, que é que você pode realmente aninhar operações ternárias. Então, tudo fora de nossa declaração inteira e nossa linha de pecado, vamos seguir em frente e nos livrar disso. Então. Vamos criar uma string e chamá-la de resolvida. E não vamos dar um valor a isso agora. Então, aqui embaixo, vamos seguir em frente e ver o resultado. Defina isso como igual a. Vamos prosseguir e colocar a condição de operador ternário. Então, entre parênteses, vamos realmente dizer que número um é igual a 0. Em seguida, vamos continuar com um ponto de interrogação entre aspas , exatamente assim. Em seguida, colocaremos dois pontos e depois outra operação ternária. Então vá em frente e coloque um parêntese aberto. E diremos num um maior que 0, seguido por um parêntese fechado. Em seguida, colocaremos isso em outro ponto de interrogação. E diremos citações positivas lá. Depois disso, colocaremos dois pontos seguidos de negativo entre aspas. E então vamos colocar um parêntese próximo e um ponto e vírgula. E então, de volta aqui, onde dissemos num um maior que 0, vamos colocar parênteses abertos. Tudo bem, então vamos detalhar isso. Pessoalmente, acho que parece confuso, mas se você ver isso no código de alguém, quero que você possa ler isso e saber como isso funciona. Então, bem rápido, só para mencionar isso. Sim, poderíamos ter colocado tudo isso aqui. Eu só não queria acrescentar mais nada a essa já louca linha de coisas. Granitic só quer definir uma string. De qualquer forma, vamos em frente e repassar isso. Então, definimos um resultado igual a, e então queríamos defini-lo igual a qualquer que fosse o resultado de toda essa coisa louca. Nós dissemos, é número um igual a 0. Se fosse, então queremos dizer que o resultado é igual a 0. Ok, legal. Então, se num um for igual a 0, diremos 0. Mas se não for igual a 0, então vamos fazer outra operação ternária aqui. Então eu sou um número maior que 0. Então, queremos definir um resultado igual a positivo e se nada for igual a negativo. E então colocamos todos esses parênteses apenas para ter certeza de que a ordem das operações estava correta. Então ele disse como número um igual a 0 se sim, então dissemos 0. Caso contrário, queríamos definir um resultado igual ao que estava nesses parênteses que queríamos fazer com toda essa operação. Primeiro, dissemos num um maior que 0 para essa condição se sim, começaremos com o positivo. Caso contrário, vamos defini-lo como negativo. E então nós simplesmente colocamos isso entre seu próprio conjunto de parênteses para garantir que o resultado fosse igual ao resultado total dessa operação, certo? Então aí está. Agora você já sabe como usar o operador ternário. Agora, eu, pessoalmente, não uso muito isso, mas já vi isso em muitos códigos de outros programadores. Então, eu queria ter certeza de incluir este curso para que vocês soubessem o que era, o que significava e como funciona. E quem sabe. Você pode pessoalmente gostar muito e querer usá-lo para si mesmo. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 34. Capítulo 7 (Loops): Introdução a loops: Neste vídeo, vou dar uma breve introdução aos loops e à programação. Nos próximos vídeos, criaremos nossos próprios tipos diferentes de saltos. Então, aqui, eu tenho a sintaxe básica ou uma regra de como um loop funciona. Basicamente, você terá uma condição, e essa condição funciona da mesma forma que em uma declaração if. Então, essencialmente, se essa condição for verdadeira, vamos executar um determinado bloco de código. E depois que esse bloco de código for executado, ele verificará novamente se essa condição é verdadeira. E se for, vamos fazer isso de novo. E vai continuar fazendo isso repetidamente até que nossa condição seja falsa. E então, quando essa condição for falsa, ela sairá do ciclo e continuará lendo o código. Aí, você a tem. Basicamente, teremos a condição, e essa condição é verdadeira. Vamos executar alguns códigos e continuaremos executando esse código até que a condição seja falsa. Então, espero que isso tenha feito sentido. Caso contrário, você verá vários exemplos disso nos próximos vídeos. Então, como sempre, obrigado por assistir, e nos vemos na próxima. 35. 34: Neste vídeo, falaremos sobre o loop while, que provavelmente é o loop mais básico que você verá. Eu tenho a sintaxe para isso aqui. Então, o que você vai fazer é escrever bem e em letras minúsculas. E então, entre parênteses, você vai colocar uma condição que você quer verificar para ver se é verdade, então uau, essa condição é verdadeira. Você fará tudo o que tiver dentro do seu bloco de código ou entre colchetes. Depois disso, ele continuará executando esse bloco de código até que essa condição seja falsa. Então, vamos escrever um dos nossos. E também vou falar sobre alguns dos problemas que você pode enfrentar se não tomar cuidado. Então, por enquanto, vamos criar um número inteiro. Vou chamar esse iterador e defini-lo como igual a zero. Então, bem, isso criará nosso loop while. Então, diremos: uau. E então, entre parênteses, diremos que o iterador é menor que 100. E, em seguida, puxar isso entre colchetes criará um bloco de código que queremos executar. Então, vamos dizer algo como CL iterator. Então na fila. Agora, não fique à nossa frente aqui e execute esse bloco de código, pois ele pode travar seu programa, se não seu computador e Jenna, e eu vou te dizer o porquê. Portanto, temos int iterator igual a zero. E então dissemos, bem, nosso iterador é menor que 100. Queremos imprimir isso. Mas essa condição nunca será falsa, certo? Então, ele vai passar, vai imprimir o iterador. E então vai dizer, tudo bem, vamos verificar nossa condição novamente. A condição ainda é verdadeira. Vamos fazer isso de novo e novo e de novo e de novo. Então, o que precisamos fazer é criar um caminho para que nossa condição seja falsa. Porque se você não fizer isso, esse código será executado infinitamente. Então, aqui embaixo, vamos dizer isso, iterator plus, plus. Vou colocar um ponto e vírgula no final. Então, agora nosso iterador aumentará em um toda vez que esse bloco de código for executado, então ele verificará a condição e continuará fazendo isso até que o iterador seja igual a 100 , porque então não será mais inferior a 100. Então vá em frente e execute o código. Como você pode ver, ele imprimiu imediatamente diferentes linhas de código começando do zero até 99. E se quiséssemos imprimir de um a 100, por exemplo, poderíamos simplesmente mudar nosso iterador para um e fazer isso dissesse menor ou igual a 100. Executamos isso de novo, vamos imprimir um até 100. Agora, uma coisa a observar é que ele não verificará a condição novamente até o final do bloco de código. Então, ele executará tudo dentro do seu bloco toda vez que essa condição for verdadeira e, em seguida, verificará a condição novamente. E somente quando essa condição é falsa, o que sai daí e continua lendo seu código. Então, se, por exemplo , aqui embaixo, dissemos C para fora, jogássemos uma linha N lá e executássemos nosso código novamente. Você pode ver que, assim que chega a 100, a impressão é concluída. Agora, outra coisa que eu quero que vocês saibam, que funciona tanto com declarações if quanto com essa, porque uma é a mesma coisa que verdadeira, porque não é como herói. Essencialmente, colocar um aqui é o mesmo que dizer verdade. E colocar o zero aqui é o mesmo que dizer falso. Então zero é o mesmo que falso e um é o mesmo que verdadeiro. Todo, você nunca gostaria de dizer que é verdade aqui. Porque, embora isso seja possível, você não conseguirá fazer com que isso diga falso. Então aí está. Eu sei como criar e usar um loop while. E sim, você pode. Você ajuda a colocar loops e declarações if ou qualquer código que você quiser dentro deles. Então, para recapitular, para criar um loop while, você só vai dizer, bem, você vai colocar uma condição que pode eventualmente se tornar falsa e se tornará falsa dentro do contexto do seu loop. Então, antes tínhamos um iterador menor ou igual a 100, e então tínhamos uma maneira de essa condição se tornar falsa, se ainda não fosse quando encontramos o mundo pela primeira vez. Porque se esse fosse falso, isso teria sido ignorado em primeiro lugar. Então você vai dizer, bem, entre parênteses, você terá uma condição que pode se tornar falsa dentro do contexto do seu loop, se ainda não for falsa. E, finalmente, você terá seu bloco de código. O que fizemos aqui, onde tínhamos um iterador para analisar a cada vez. Nossa marca de loop é uma forma muito comum de sair de um loop em algum momento. Agora, antes de terminarmos, vamos analisar outro caso de uso para isso. Então, vamos ao meio disso e diremos int response. Defina isso como um. E então Dumbo, que dirá, uau, entre parênteses enviará resposta não igual a zero. E então, em nossos colchetes encaracolados, diga C out. Por favor, pegue o zero e use o que dirá Veja na resposta. Agora, creditamos um link chamado resposta e esse n é igual a um. E então dissemos que uma resposta não é igual a zero, que definitivamente não será a primeira vez. Vamos imprimir, digite zero e pressione Enter. E se o usuário não digitar zero, esse código será executado novamente. No entanto, uma vez que eles digitaram zero, ele dirá apenas concluído. Então, se executarmos um programa, ele dirá Por favor, pegue zero e pressione Enter. E podemos pegar qualquer número e pressionar Enter. E pedirá que façamos de novo. Poderíamos fazer isso para sempre, se quisermos. Caso contrário, se digitarmos zero e pressionarmos Enter, ele dirá concluído e pronto. Então, esse é apenas mais um exemplo de como poderíamos ter usado nosso loop while e ter uma maneira de sair dele sem usar um iterador. Agora, bem rápido, eu quero deixar algo bem claro. Se estivéssemos aqui, defina uma resposta igual a zero, por exemplo , em nossa condição de loop while, resposta é igual a um, isso realmente funcionaria para sempre. E a razão para isso é porque, na verdade, estaríamos atribuindo uma para responder. Então, dizemos que a resposta é igual a um. E por causa disso, o loop while na verdade encararia isso como exatamente isso. E, como sabemos, uma é a mesma coisa que dizer verdade. Então isso pode muito bem dizer: Bem, é verdade. Mesmo que quiséssemos dizer verificar se a resposta era igual a um. Portanto, sempre que você estiver trabalhando com uma condição, certifique-se de nunca usar apenas o operador de atribuição. E você sempre diz que é igual a colocando dois sinais iguais, pois você definitivamente não quer travar seu programa, especialmente se esse for um pedaço de código no qual você está trabalhando há muito tempo e Eu não economizei ou algo parecido. Pode ser muito traumático. Então, só queria te dar um aviso sobre isso. Então, espero que agora você saiba como escrever e usar um loop while e possa até pensar em alguns exemplos e na sua cabeça de onde isso seria útil. De qualquer forma, o que eu realmente quero que vocês façam é ir em frente e salvar o que vocês têm aqui. Então, vamos usá-lo no próximo vídeo quando falarmos sobre um loop do while. Então, como sempre, obrigado por assistir, e nos vemos na próxima. 36. Capítulo 7 (Loops): Faça enquanto loops: Neste vídeo, falaremos sobre algo chamado de loop do while. E se você se lembra do último vídeo, eu pedi que você salvasse tudo o que você tinha. No entanto, se por algum motivo você não fez isso, não se preocupe. Vá em frente e pause o vídeo. Copie esse pequeno trecho de código aqui e você estará pronto para começar. Então, eu tenho a sintaxe básica para um loop do-while aqui. Vale a regra de como escrever um. Você vai fazer tudo em letras minúsculas. E então, entre colchetes, você terá seu bloco de código que deseja executar pelo menos uma vez. E só vai rodar uma vez, não importa o que aconteça. Depois disso, você vai dizer, bem, assim como fizemos no passado, e depois parênteses, você terá uma condição. Se essa condição for verdadeira, seu bloco de código será executado repetidamente até que a condição seja falsa, então você também precisará de um ponto e vírgula após essa condição. Portanto, a principal diferença entre um loop do while, um loop while diferente de como ele é escrito como seu bloco de código, será executado uma vez, não importa o que aconteça. E então só vou repetir enquanto a condição for verdadeira. Tudo bem, então vamos dar uma olhada em como criar isso e criar um para nós mesmos. Então, aqui embaixo, vamos transformar nosso loop while em um loop de fazer enquanto só para mostrar o quão comparáveis eles realmente são. Então, aqui, vamos dizer “faça” em letras minúsculas. E então vamos cortar nosso bloco de código aqui do loop while anterior e colocá-lo na frente da palavra fazer. E depois de uma condição de loop de algum tempo, colocaremos um ponto e vírgula assim. E aí está. Agora criamos um loop do while. Então, o que ele vai fazer agora é dizer Por favor, digite 0 e pressione Enter. E então eu vou deixar o usuário uma resposta sendo nós neste caso. E então, embora a resposta não seja igual a 0 , eles vão em frente e mudam, o que continuará se repetindo. E então, quando terminarmos, ele dirá: Vamos em frente e mudar isso para algo como agradecimento. Agora, se executarmos nosso código, ele dirá Por favor, digite aqui e pressione enter como resposta. E enquanto essa resposta não for 0, ela continuará se repetindo. O que é a é 0, ele dirá, obrigado. Então, se executarmos nosso código aqui, você pode ver que ele diz por favor, digite 0 e podemos digitar o que quisermos e continuar pressionando Enter e repetidamente até digitarmos 0. Então entramos, ele dirá, obrigado, e lá vamos nós. Portanto, observe que esse código foi executado mesmo que a resposta fosse igual a 0, nessa condição era falsa porque a resposta era 0. Isso só teria sido verdade e não era igual a 0. Então, como eu disse, a única diferença entre um loop while e um loop do while é a sintaxe ou como você vai escrevê-lo lá, e o fato de que seu código será executado uma vez. Portanto, independentemente da resposta anterior, esse código será executado uma vez. E então ele verificará se a resposta é 0 antes de liberar esse código. Como dissemos que se a resposta não fosse igual a 0, queríamos continuar executando esse código. E aí está. Agora você já sabe como criar um loop do while. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 37. Capítulo 7 (Loops): para loops: Neste vídeo, veremos como criar e trabalhar com algo chamado loop for. Eu tenho a sintaxe básica de uma para você aqui. Então, primeiro, você vai economizar para em letras minúsculas e depois entre parênteses, teremos algumas coisas diferentes. Primeiramente, teremos uma inicialização variável. E não se preocupe, eu vou te mostrar o que quero dizer com isso aqui em breve. Então você vai continuar com um ponto e vírgula. E depois disso você vai ter uma condição. A condição Let's funciona exatamente como em qualquer outro loop. Portanto, embora a condição seja verdadeira, seu código continuará se repetindo. E depois disso, você terá uma atualização de variável, que é onde você atualizará a variável que você criou. Então, deixe-me ir em frente e mostrar o que isso parece bem rápido. Eu queria que você soubesse que todas essas coisas poderiam ser tecnicamente removidas de um loop for-loop sem erros, desde que você deixe os dois pontos e vírgulas lá. No entanto, se você não tiver a condição intermediária, isso sempre será considerado verdadeiro. E você teria um loop infinito, que, como eu disse no passado, você normalmente sempre quer evitar. Então, vamos seguir em frente e criar um loop for. E as mulheres criam um loop for. Na verdade, vamos tentar obter o mesmo resultado que obtivemos com nosso loop while em um vídeo anterior, onde imprimimos de um a 100 em linhas separadas. Só para que eu possa mostrar se há diferenças entre um loop for e um loop while. Então, desligue, vamos dizer quatro. E então, entre parênteses, diremos que int I é igual a 0, o ponto e vírgula no final. E aí está. Ali mesmo, temos nosso teto de inicialização de variáveis criado e inicializado uma variável. E você pode nomear isso como quiser. Você também pode definir isso igual ao que quiser, mas muitas vezes defini-lo como igual a 0 e vê-lo chamado I é o mais comum, sendo a abreviação de iterador. E você verá o porquê em apenas um momento. Em seguida, teremos nossa condição. Então, vamos dizer que eu sou menor ou igual a 100. Eu não coloco um ponto e vírgula depois disso. E logo depois disso, atualizaremos nossa variável sempre que você atualizar o valor da nossa variável. Então, digamos que eu mais, mais. E então teremos nosso bloco de código dentro daqui. Vamos simplesmente imprimir, direi C0. E então criaremos uma nova linha como essa. E esse ciclo é bom para continuar como está. Então, vamos resumir o que está acontecendo aqui. Então dissemos para, para declarar que estamos criando um loop for. E então, entre parênteses, temos todas as coisas que são básicas para loop Ouvimos falar de uma variável em que dissemos int I é igual a 0. Em seguida, colocamos um ponto e vírgula para separar isso da condição, digamos que eu seja menor ou igual a 100. Essa é a condição que precisa ser atendida para que um loop for seja executado em primeiro lugar. E se ele vai continuar funcionando, isso deve continuar sendo verdade. E depois de cada vez que nosso código for executado, ele aumentará I em um. E também poderíamos ter dito que eu mais é igual a um ou eu é igual a I mais um. Realmente não importa. Esse é apenas o espaço que você deseja ter para atualizar sua variável. Então, muitas vezes é assim que você verá um I graduado em for-loop igual a 0, I com uma condição e depois eu mais, mais ou mais mais I. Como eu disse, eu é a abreviação de iterador, mas você Eu posso chamar isso do jeito que você quiser. E então, em vez de for loop, nós simplesmente imprimimos. Em seguida, criei uma nova linha. E o que isso vai fazer é imprimir de 0 a 100. Mas se mudarmos isso para um aqui, eu vou imprimir 100. Então, vamos seguir em frente e executar nosso código. E aí está, um até 100. Então, quando você cria um loop for, normalmente criará algum tipo de variável com a qual trabalhar. Você terá a condição de que deseja ser atendida. E se essa condição for atendida, ela passará pelo seu código. E depois de executar seu código, ele irá para sua variável até aqui, faça o que for mandado fazer. Então, neste caso, dissemos I plus plus. Então, vou aumentar um porque é isso que o I plus faz, como sabemos do passado. E depois dessa atualização de variável, ele verificará nossa condição. Novamente. Se nossa condição ainda não for atendida, ela passará por esse bloco de código novamente. Então, quando essa condição for falsa, ele continuará com nosso código. E sabemos disso do passado. E se quiséssemos, poderíamos dizer C0, feito aqui embaixo e linha assim. E o que ele fez, ele será impresso. Ok. Agora, e se não quiséssemos aumentar I em apenas um? Bem, como eu disse, você sabe, meio que coloque o que quiser aqui. Mas esse é o local que você quer ter para atualizar sua variável. Então, poderíamos dizer que eu é igual a I mais dois. E lá vamos nós. E vai imprimir um porque nossa condição era verdadeira. Eu sempre acho que imprimiu um e depois foi adicionado a I. Então eu tinha agora três. Isso ainda é menos de 100 impressos em três, e assim por diante. E se os mudássemos para 0 aqui, então, essencialmente, imprimiríamos todos os números pares. Então, como você pode ver, 24681012 e assim por diante. Tudo bem, então quando você usaria um loop for em vez de um loop while? Bem, por um lado, um loop for é mais rápido do que um loop while. Além disso, você normalmente deseja usar um for-loop quando sabe exatamente quantas vezes deseja executar um loop Vamos fazer algo assim. Eu tenho menos de dez anos. Vamos imprimir esse ID e aumentá-lo em um. Agora, se o executarmos, ele passará exatamente dez vezes. Então, obtivemos 12345678910. Então, quando você sabe quantas vezes deseja executar um loop, normalmente, você usará um loop for quando a condição de que precisa ser atendida para interromper a execução ao vivo. Por mais complexo que seja, você geralmente vai querer usar um loop while. E então, para um loop “do-while”, você só quer usá-lo quando você sabe, você quer que um pedaço de código seja executado pelo menos uma vez e, em seguida, você quer que ele se repita se uma condição for atendida. Mas, na maioria das vezes, você provavelmente usará apenas para loops e loop while. Agora, para finalizar este vídeo, quero voltar rapidamente ao que falei anteriormente onde disse que podemos ter um loop for exatamente como este. E isso será totalmente válido. No entanto, sem uma condição, ele funcionará infinitamente. Mas dito isso, isso é válido e você pode colocar o que quiser. Então, bem rápido, vamos dar um exemplo de remover tudo , exceto nossa condição. Então, poderíamos ter dito int i. Então, em nossa inicialização de variável, poderíamos simplesmente definir i igual a 0, ou poderíamos tê-lo retirado inteiramente e dito que I é igual a 0 aqui em cima e simplesmente não ter um inicialização de variáveis. No entanto, ainda precisamos do ponto e vírgula para separá-lo da condição aqui. Em seguida, dissemos a intenção do iOS e poderíamos até mesmo retirar nossa atualização variável. Não tem problema. No entanto, se fizermos isso, como eu disse, você sempre quer ter certeza de que há uma maneira de seu loop parar no reino do seu loop. Então, dentro do nosso loop, poderíamos ter dito I plus code. E como você pode ver aqui assim como antes, sem problemas. Você não precisa ter tudo na mesma linha aqui, e funcionará muito bem. Apenas certifique-se de que você ainda tenha alguma maneira de sair do loop e de ter uma variável com a qual possa realmente trabalhar. É por isso que o criamos aqui novamente. Agora, eu só queria te mostrar que isso era possível. Na maioria das vezes, você provavelmente não fará isso, mas essa é uma opção. E caso você veja isso no código de outra pessoa, você saberá o porquê, saberá como está funcionando e assim por diante. Mas, na maioria das vezes, você provavelmente fará isso da maneira normal que fazíamos antes. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 38. 37: Neste vídeo, falaremos sobre circuitos de nidificação. E loops aninhados são basicamente o mesmo conceito de quando examinamos o agrupamento de declarações. É basicamente apenas um loop dentro de um loop. E você pode continuar fazendo isso repetidamente, assim como faria com essas declarações ou qualquer outra coisa. Então, vamos dar uma olhada em como isso pode funcionar. Então, vamos criar alguns loops for para este exemplo. Então, diremos que para int I é igual a zero, I menor que dez e depois I mais mais. Lembre-se de que essa será basicamente a aparência de todos os seus for-loops básicos. Então, de qualquer forma, dentro daqui, eu vou dizer CL. Eu simplesmente gosto disso. Então, abaixo disso, vamos criar outro loop for. Então eu vou dizer que para j é igual a zero, j é menor que dez. J mais mais. E o bloco de código para isso, vou dizer apenas cl j. E antes de executar um código, vamos realmente remover a linha M daqui de cima. Ou dissemos CRI e eu vou embora. Então, vamos dar uma olhada no que aconteceu aqui. Então, a primeira vez que imprimimos é zero porque era isso que eu era. E então entramos em nosso outro loop for. E vamos chamar isso de nosso pronome j for-loop. Outra maneira pela qual você pode ouvir falar de alças chamadas quando você tem alças de nidificação como internas e externas. Primeiro imprimiu I, isso era zero, e depois imprime j, que também era zero. Então J foi aumentado em um. Então j era igual a um, que ainda é menor que dez. E então imprimiu J novamente em uma nova linha porque temos essa linha N aqui. E eu sinto isso até as nove. Quando eu fiz nove, Jay não tinha mais que dez anos. Portanto, não imprimiu j novamente. Em seguida, fui aumentado em um. Então eu era agora um e ele imprime um. Depois disso, começou nosso loop for sobre j era igual a zero. J tem menos de dez. Imprima j, j era zero e passou até nove novamente. E eu continuei fazendo isso e fazendo isso e fazendo isso e fazendo isso até que finalmente eu tinha nove anos. Ela foi para zero novamente, imprima-os até o fim. E então, uma vez que eu sempre era igual a dez, ele parou. Agora, se quiséssemos que isso parecesse um pouco melhor, por exemplo, poderíamos ter impresso I junto com ele. Então aqui embaixo, vamos dizer C para fora I. E então vamos imprimir j. Então vamos continuar e remover a CLI aqui em cima. E agora, quando executamos nosso código, na verdade ele vai dizer 00 porque i e j eram ambos zero, depois zero para i , um para j, zero Froude para j. E vai continuar fazendo isso até nove . Vou imprimir apenas um para IA porque IA aumentará em 10 para j e assim por diante. E apesar de estarmos imprimindo dois números diferentes, na verdade imprimimos zero até 99 lá. E uma maneira interessante de imprimir 100 é dentro do nosso loop J4. Poderíamos ter dito que se I fosse igual a nove e j fosse igual a nove, então queremos ver 100. Então, se executarmos nosso código novamente, você pode ver que imprimimos de zero a 99, assim como antes, exceto quando eu era igual a nove e j era igual a nove, também imprimimos 100. Então aí está. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 39. Capítulo 7 (Loops):: Neste vídeo, falaremos sobre a declaração de interrupção. A instrução break é algo que você já viu antes quando trabalhamos com interruptores e digitamos algo como essa linha de interrupção com um ponto e vírgula. Agora, a instrução break, como você pode ver aqui, só pode ser usada dentro de um loop ou switch. E já vimos como isso funciona dentro de um switch. Hoje, vou mostrar como podemos usá-lo com loops. Agora, o que o tronco cerebral faz é automaticamente tirar você do circuito, e ele faz isso instantaneamente e não continua com o resto do código. Então, vamos ver como isso funciona. Então, aqui, vamos criar um número inteiro. Vamos apenas chamar isso de i e defini-lo como igual a 0. Então, abaixo disso, vamos criar um loop while infinito. Agora, eu sei que eu disse, normalmente você não quer criar um loop infinito porque você nunca vai sair dele. Mas com uma declaração de pausa, você realmente pode. Então, eu vou te mostrar como isso funciona agora. Então, vamos dizer uau. E, dentro disso, vamos dizer verdadeiro e criar um bloco de código. Então, neste momento, esse loop seria executado infinitamente, mas na verdade vamos fazer que possamos sair disso. E dentro daqui, diremos “I plus”, plus”, assim mesmo. Abaixo disso, vamos criar uma declaração if. Eu vou dizer que def I é igual a dez. Então, queremos sair do circuito. E você só vai dizer break e tudo minúsculas com um ponto e vírgula no final. E isso vai nos tirar de todo o ciclo. Ok, então aqui embaixo, vamos dizer CL loop. Assim mesmo. Observe também que coloquei nosso iterador sendo eu, nesse caso, fora do nosso loop. E o operador final é basicamente apenas algo que você está usando para iterar em um loop x quantidade de vezes. Então, se quisermos colocá-lo aqui em vez disso, seria infinitamente porque toda vez que passamos por um loop, eu teria sido criado e definido como igual a 0. Eu teria sido aumentado com uma mão, nunca teria sido igual a dez. E isso vai acontecer repetidamente e mais e mais. Mas se a colocarmos na parte superior do nosso loop, essa variável será armazenada e salva fora do loop. Lembre-se de aumentá-lo um na próxima vez no loop, ele aumentará em um. Novamente, mais ou menos como quando tínhamos esse laço interno e o retiramos. Então, o que vai acontecer? Vamos criar um número inteiro chamado i, defini-lo como igual a 0. Este será nosso iterador para nosso próximo show. Em seguida, criamos um loop infinito quando dissemos: Bem, é verdade. Mas cada vez que passamos por um ciclo, aumentaremos em um. Então, ele vai começar em 0 e ir para 1234, etc. Então, quando eu for igual a dez, temos essa declaração de interrupção aqui para nos expulsar do loop. E logo abaixo, realmente quero imprimir, eu gosto disso. E vamos colocar uma nova linha a cada vez. E eu vou te mostrar o porquê em apenas um segundo. Agora, vamos seguir em frente e executar nosso código. Agora, como você pode ver, pegamos 123456789, mas não imprimimos dez. Uma vez. Eu era igual a dez de nós, aumentando em um, aqui mesmo, verificou nossa declaração if. Eu disse que sim, e então isso nos tirou disso e não continuou com o resto do código e nosso loop, somos imediatamente eliminados dele assim que ele atinge essa declaração de interrupção e continua com o código. É por isso que não imprimimos dez. Então aí está. Agora você sabe como usar a instrução break. Basicamente, você vai fazer pausa, jogar um ponto e vírgula e isso o expulsará de um loop ou de um bloco de código quando você usar com switches, como vimos no passado. E é essencialmente a única maneira de você sair de um ciclo infinito, como você vê aqui. Mas você pode usar isso de outras formas e não apenas em loops infinitos, certo? Poderíamos ter dito, se eu tivesse menos de 100, e então isso teria funcionado 100 vezes e parado. Mas quando atingirmos dez, ou vamos definir isso para algo como 30, vamos em frente e nos expulsará de qualquer maneira. Então, como você pode ver, quando obtivemos os 30, ele nos expulsou e não se preocupou em imprimi-los. É assim que use a instrução break para expulsá-lo mais cedo do ciclo. Há vários motivos pelos quais você pode querer fazer isso. Obviamente, aqui parece um pouco redundante, mas você pode querer executar um loop uma certa quantidade de vezes até que uma determinada condição seja atendida e, em seguida, vá em frente e saia dela imediatamente e lá. E para mostrar um exemplo disso, poderíamos ter dito uma senha de string e defini-la como igual a, vamos defini-la como nada por enquanto. E então, dentro daqui, poderíamos ter dito: Bem, a senha não é igual a. E então vamos dizer a senha 123 porque temos a senha mais segura do mundo, a correta. E então aqui embaixo vamos dizer a senha cin, sem mais nem menos. E então, se a senha for igual a, digamos pare. Vamos prosseguir e mudar isso para sair. Vamos seguir em frente e sair do circuito. Portanto, embora a senha não seja igual à senha 123, continuaremos solicitando uma senha. E você pode realmente ir em frente e fazer isso aqui, digamos, por favor, digite a senha correta. Assim mesmo. Em seguida, solicitaremos uma senha. Se eles colocarem a senha correta aqui embaixo, eu direi. E vamos cortar isso. E dentro do nosso loop, diremos que a senha é igual a. E então diremos a senha. 123, vamos dizer parabéns. Caso contrário, se a senha for igual a exit, seguiremos em frente e sairemos. E eu vou imprimir a saída. Dirá algo como sair ou sair. Agora, obviamente isso não é perfeito. Na verdade, não temos nada depois disso, mas esse é apenas um exemplo de como você pode usar um loop while e por que você pode querer ter uma instrução break para outras opções. Então vá em frente e execute-o. Agora ele vai pedir uma senha. Eu posso digitar o que eu quiser. Isso será salvo na string. Se não for o caminho, senha. Só vai continuar me dizendo que se sairmos, ele dirá “saído” e lá vamos nós. Agora, se eu executá-lo novamente e pegar a senha 123, direi parabéns. Agora, e se quiséssemos dar ao usuário apenas algumas tentativas? Bem, depois de fazermos isso e depois de verificarmos se a senha era igual a 123, poderíamos até fazer outra pausa aqui. Se quisermos que esteja aqui, diremos que a senha estava correta. Depois disso, diremos “i” e depois tentaremos. Senha que estava incorreta. Tentativas. E então, fora do nosso lábio, criará um vazio. Defina-o igual a. Então, na verdade vamos definir como igual a, ok, porque eu não quero que eles tenham alguma quantidade de tentativas. E então aqui embaixo, logo abaixo dela, logo acima da nossa linha CL dirá I menos menos, e depois coloque um ponto e vírgula. Então, ele vai ver como a senha está incorreta. Então eu vou imprimir se eu tentar, certo? Então, vamos começar com cinco. Não entenda direito. Eu direi a senha está incorreta para tentativas à esquerda, ao centro, à direita? Então vá em frente e execute nosso código. Pegamos algo, digamos que a senha está incorreta nas tentativas restantes, digite a senha correta, 3210. E, infelizmente, vai continuar sendo negativo, a menos que façamos algo a respeito. Então, aqui, podemos dizer que, se eu for igual a 0, imprima você no breakout mais cedo, assim mesmo. E depois disso, vamos fazer uma nova linha para que ela limpe nosso código um pouco melhor quando falhamos. Está aqui mesmo. Por favor, ter a senha correta digitada em algo errado. Servidores incorretos. Restam quatro vezes, restam três temas para 10 vezes restantes. Juventude, Ben, bloqueado e aí está. Agora, criamos uma ideia muito básica para um programa de senhas. Então, espero que você tenha uma boa ideia do que os quebra e como usá-los. E talvez você tenha algumas ideias agora sobre quando usá-lo. Espero que você tenha gostado do vídeo como sempre, obrigado por assistir, e nos vemos no próximo. 40. Capítulo 7 (Loops): Continue as declarações: Neste vídeo, vamos dar uma olhada na declaração de continuação. Agora, como a declaração de interrupção sobre a qual falamos no último vídeo, a instrução continue também é usada ao trabalhar com loops. Então, vamos dar uma olhada em como isso funciona. Primeiramente, vamos criar um loop for. Então, vamos dizer que para int I, defina-o igual a 0. Então, se houver menos de dez, eu mais, mais, exatamente assim. Então, dentro do nosso for-loop aqui, vamos imprimi-lo então vamos dizer que eu crio uma nova linha depois, assim. Então, acima de nossa declaração c out aqui, vamos em frente e criar uma declaração if. Então, vamos dizer que é igual a. E vamos colocar algo como cinco aqui. Então, queremos fazer o seguinte. que vamos fazer é colocar a declaração de continuação. Então, vamos dizer continue, tudo em minúsculas. E o que isso faz é, na verdade, ignorar a iteração atual de um loop. E também mostrarei como isso funciona e também um loop de tempo. Então, o que vai acontecer aqui? Bem, se não tivéssemos essa declaração if, sabemos que normalmente imprimiríamos de 0 a nove, mas como temos isso aqui, assim que eu for igual a cinco, ele vai ler isso, continue declaração. Vamos pular todo o resto depois disso. Mas, ao contrário de uma declaração de interrupção, que nos expulsaria totalmente do circuito, o que acontecerá em vez disso, pois ela vai subir aqui e ler nossa atualização de variáveis. Então, neste caso, ele vai atualizar I por um. E então ele verificará a condição novamente e continuará em frente. Então, o que acontecerá é que imprimiremos de 0 a quatro e depois passaremos para o sexo e em diante. E se executarmos nosso código aqui, você pode ver que foi isso que aconteceu. Então, imprimiu 01234. Então, uma vez que eu era igual a cinco, continuo. Então eu fui em frente, pulei aqui para nossa atualização de variáveis, li isso por um. Então, eu tinha agora seis anos e depois continuou normalmente. Então aí está. É assim que a instrução continue funciona em um for-loop. A propósito, bem rápido, com a instrução continue e a instrução break, se você tiver um loop aninhado. Então, digamos que tivéssemos outro loop fora deste. Então, se tivéssemos algo assim, agora, vocês não precisam copiar isso aqui. Só estou tentando mostrar a vocês a que estou me referindo. Mas, basicamente, se você tiver um loop aninhado aqui, sua declaração contínua e, ou sua instrução break afetará apenas o loop que ela é. E isso aqui afetaria apenas esse loop e não o loop externo. E se isso fosse uma declaração de ruptura, ela só nos tiraria do circuito interno e não do externo. Então, se eu continuar e imprimir, eu gosto disso e imprimir j. Eu pego minha nova linha aqui e executo meu código. Então, agora, se você olhar nosso código aqui, você pode ver que imprimimos 0 para r I e, em seguida, para a variável J fomos 01234, pulamos para a próxima iteração do nosso loop, que também aumentou j em um neste caso e depois continuou. E fez isso todas as vezes por causa de nossa declaração contínua. E como clicamos em uma instrução break aqui, como usamos no último vídeo, e executamos nosso código. Você pode ver que ele só sai do loop atual. E então só vamos de 0 a quatro com nossa variável j, e ela continua fazendo isso toda vez. Então aí está. Então, como ele continua a declaração de trabalho, o ciclo while? Bem, funciona exatamente da mesma maneira , exceto que não temos uma atualização variável. Então, se for algo como int, eu é igual a 0 aqui em cima. E então, em nosso loop while, dissemos que enquanto eu tinha menos de dez anos e dentro do nosso bloco de código aqui, vamos prosseguir e imprimir Eu crio uma nova linha. E então também queremos ter certeza de que temos uma maneira de sair desse ciclo de tempo, certo? Eu não quero que isso continue para sempre. Então diga eu mais, mais assim. Então, sem que nada seja feito com isso, sabemos que ele imprimirá um a dez códigos Fahrenheit aqui. Podemos ver que esse é o caso. Mas e se incluirmos nossa declaração contínua? Então, se dissermos que eu é igual a cinco, mais uma vez, tenha cuidado para garantir que isso seja igual a. E então aqui vamos apenas dizer para continuar. Assim. Quando chegar à nossa declaração contínua aqui, isso só vai verificar novamente a condição e não fazer nada a mais. E essa é outra razão pela qual gostaríamos que o I plus plus ou nosso iterador estivesse aqui antes da sustentação. Porque se fosse depois, assim, primeiro, passaria, aumentaria isso em um. Então, digamos um, imprima e continue fazendo isso até os cinco anos. Agora, quando eu tinha cinco anos, continuaria e verificaria nossa condição novamente. E cinco é menos de dez. Então, passe por isso novamente e continue correndo, correndo e correndo para sempre. Portanto, queremos ter certeza de que o que está fazendo com nosso loop while termine aconteça antes disso aqui, pelo menos nesses casos, para não criar um loop infinito que interrompa nosso programa. Então, se eu executar o código aqui, você pode ver que imprimimos 1234. Quando atingimos F5, continuamos e renderizamos novamente a condição seis. Então, não é mais igual a cinco e depois continuou a ser impresso. Então aí está. Agora você já sabe como criar e usar a instrução continue. E lembre-se, tudo o que ele faz é pular a iteração atual do loop. E com um loop de tempo, ele só vai verificar novamente a condição. E com um loop for, se você tiver uma atualização variável lá, isso fará isso primeiro e depois verificará sua condição de qualquer maneira, é isso para este vídeo. Como sempre, obrigado por assistir e nos vemos na próxima. 41. Capítulo 7 (Loops): Validação de entrada de usuários: Neste vídeo, mostrarei como podemos realmente validar a entrada do usuário. Até agora, neste curso, estamos apenas nos certificando de que estamos digitando os valores corretos. Então, por exemplo, se um dos usuários ou nós mesmos, nesses casos, digitar um número inteiro, acabamos de digitar um número inteiro. Mas se realmente digitássemos algo como “olá”, teríamos alguns problemas. Agora, dependendo do tipo de programa que ela criará, isso pode ou não ser um problema para você, pois talvez você nunca precise receber informações aleatórias do usuário para garantir que estejam corretas. Mas eu quero mostrar como isso é feito caso você precise, ou caso você queira implementá-lo em qualquer programa que você possa criar bem, tentando aprender e entender a linguagem. E só para que você tenha isso à sua disposição e possa reconhecê-lo se o ver no código de outra pessoa. Agora, apenas um aviso rápido, provavelmente não vou usar isso durante o resto deste curso. Este vídeo estará aqui apenas para referência e para você aprender como fazer isso, use choose. A principal razão para isso. Seremos apenas por causa da complexidade extra, mas acho que isso aumenta o código. E, pessoalmente, eu simplesmente não o uso muito no código que faço usando o C plus plus. E vamos só porque eu geralmente trabalho com desenvolvimento de jogos e não tenho os usuários apenas digitando coisas aleatórias para preencher uma variável. Mas porque estamos trabalhando com um aplicativo de console e pedindo que o usuário digite o que quiser preencher em uma variável. Acho que é relevante ensinar a você como isso funciona. Desculpe por esse pequeno discurso retórico, mas vamos começar. Então, primeiro, vamos dizer , eu gosto disso. E então vamos criar um loop while infinito para obter a entrada do usuário. Então, vamos dizer uau. E então, dentro daqui, diremos a verdade. Lembre-se de que outra forma de criar um loop infinito é criar um loop for como esse e depois fazer isso. E é isso que estamos fazendo para sempre porque não há uma condição lá. E isso apenas assumirá que a condição é essencialmente verdadeira. Mas eu gosto de usar o Wiley pessoalmente porque acho que é um pouco mais legível do que um quatro loop vazio. Então, vamos fazer isso e pedir ao usuário que digite um número. Então, vamos dizer C out, digite um número inteiro. Vamos fazer um espaço do cólon assim. E, abaixo disso, vamos criar uma declaração if. Então, vamos ver isso assim. Agora vamos digitar um monte de códigos que não farão nenhum sentido para você. Mas, por enquanto, vá em frente e acompanharei tudo com você no final e tentarei tornar o mais fácil possível de entender. Tudo bem, desculpe, aqui, vamos dizer uma pausa assim. Então, vou apenas fazer uma declaração de pausa. E, abaixo disso, diremos outra coisa. E então, no bloco de código da nossa declaração else aqui, vamos prosseguir e salvar o seguinte. Vamos dizer C para fora. Esta entrada era válida, digite espaço numérico. E então Dumbo, que vamos dizer, can dot Clear e depois abrir e fechar parênteses, depois um ponto e vírgula. Então, abaixo disso, vamos dizer c m dot ignore. E então, entre parênteses, vamos dizer numérico. Tudo em letras minúsculas, a propósito, sublinhado limita o tamanho do fluxo menor que o símbolo. Tudo em uma palavra, tudo em minúsculas. E então o símbolo maior que seguido por dois pontos. Lá, vou dizer max, tudo em minúsculas, espaço vírgula entre parênteses abertos e fechados. E então vamos colocar uma aspa simples como essa, barra invertida n, seguida por outra aspa simples ou parênteses fechados, e depois um ponto e vírgula no final. E isso é tudo o que precisamos validar. Nossa opinião pessoal é um pouco demais , mas essa é a maneira de fazer isso no C plus plus. Então, vamos entrar nisso. Então, aqui no topo, dissemos, por favor, digite um número inteiro. Então aqui embaixo, dissemos se CNI, então o que isso realmente vai fazer é pegar entrada como normal e , em seguida, colocar a entrada em alta. E se a operação funcionar, isso retornará verdadeiro. Em seguida, ele vai entrar no bloco de código de arte aqui, o que vai nos tirar do circuito porque finalmente obtivemos a entrada que estamos procurando. No entanto, se essa operação falhar, temos nossa outra declaração aqui para nos cobrir. Então, dizemos ao usuário: Ei, essa entrada era inválida, digite um número inteiro. Então o que fizemos foi dizer que não posso esclarecer o que é isso como um método para basicamente limpar o ar que teria surgido ao tentar colocar o que o usuário digitou em I. Esse não era um número inteiro. . Tudo bem, então essa é basicamente a maneira mais fácil de pensar sobre esse método, pois estamos apenas limpando o ar que teria surgido do usuário tentando colocar o tipo de dados errado em I. Um pequeno comentário aqui, desmarque a opção por tentar inserir o tipo de dados incorreto em nosso número inteiro. E, na verdade, direi apenas variável. Então veja, você sabe, que isso funcionaria basicamente com qualquer outro tipo de dados. Então aqui dissemos cin.ignore. E depois disso, você essencialmente coloca a quantidade de caracteres que deseja ignorar. E então essa coisa toda aqui, até esse máximo aqui, basicamente diz que queremos ignorar a quantidade máxima de caracteres que foram inseridos até esse caractere de barra invertida n. Agora, a razão pela qual ignoramos tudo. Até o novo caractere de linha, que nesse caso seria quando o usuário digitasse enter as, porque sabemos que no final de tudo o que o usuário decidiu digitar, digamos que ele digitou um livro inteiro de palavras. Quando pedimos que eles digitem um número inteiro, esse nosso programa aqui, ele vai ignorar tudo o que eles acabaram de digitar. Porque no final de tudo o que eles digitaram, eles pressionam a tecla enter, que é a mesma de um novo caractere de linha. Ignore tudo até o novo personagem de linha. Entrar. Agora, por que fizemos isso? Bem, primeiramente, eliminamos o erro que surgiu do usuário ao inserir um tipo de dados incorreto em uma variável. Então, se tivéssemos percorrido nosso loop novamente sem essa linha de código aqui, basicamente teríamos obtido exatamente o mesmo erro e isso nunca funcionaria e ficaríamos presos nisso laço. Basicamente, o que fizemos foi basicamente dizer ao nosso programa: Ei, ignore tudo o que era apenas do tipo, vamos começar do zero. Então, ao ignorar o ar e dizer ao nosso programa que ignore tudo o que estava apertado, estamos basicamente começando com uma ficha nova e limpa. Tudo bem, então espero que isso faça sentido. Além disso, outra coisa que eu gostaria de mencionar rapidamente sempre que você está trabalhando com algo assim, isso pode causar um loop infinito, como qualquer tipo de pausa em seu programa ao usar um loop infinito. Bem, muitas vezes, seja uma boa proteção contra falhas para o travamento do seu programa. Mas eu sempre diria, só para ter certeza de que já vimos muito disso antes. A única diferença é que agora você sabe que pode inserir algo assim. Então, podemos dizer CAN seguido por uma variável, como fizemos no passado. E isso realmente retornará verdadeiro ou falso, dependendo se isso funcionou ou não. Ok, e aqui embaixo temos nossa declaração de ruptura que vimos no passado que nos tirará totalmente desse ciclo. Então é assim que podemos sair do nosso loop infinito. E na parte inferior, temos isso aqui que basicamente diz, ei, sua entrada era inválida se ela retornasse falsa. E então temos essas duas linhas de código para nos dar uma ficha limpa. Então, vamos seguir em frente e executar nosso programa. E pediu um número inteiro. E eu vou pegar algo como “olá”. E observe que nosso programa não travou, não apresentou nenhum erro maluco. E, na verdade, só para mostrar mais uma coisa aqui em nossa declaração if, vamos continuar e imprimir isso. Vou criar uma nova linha como essa. Então, vamos fazer o mesmo dentro do nosso bloco de código else aqui. Veja o que está na fila para que você saiba que podemos usá-los para abril e não estamos tendo nenhum erro. Ok? Então, eu posso digitar o que eles quiserem e entrar, e isso não causará nenhum problema. Eu imprimi, eu conheço o problema. E só por segurança, mesmo que essa letra morta seja 0, eu realmente recomendaria que a inicializássemos aqui. Pessoalmente, eu recomendaria que você examinasse o valor inicial antes de fazer algo assim. Mas, como você viu, funcionou, imprimiu 0 neste caso. Mas geralmente, por segurança, isso é algo que eu recomendaria. OK. Assim, você pode digitar o que quiser. E depois disso, você pode ver que imprimimos que eu sirva que eles usam IA, sem problemas. E aqui embaixo dissemos que eles impõem ao válido, por favor, diga o número inteiro. E se quiséssemos limpar isso, poderíamos ter feito o seguinte. Podemos simplesmente tirar nosso c. Por favor, pegue o número e coloque-o aqui fora do nosso loop while. E isso vai funcionar muito bem. Então, lá atrás, o que quisermos. Podemos continuar fazendo isso o quanto quisermos porque temos um loop infinito. Aqui está um bom exemplo de quando um loop infinito é útil quando estamos tentando obter alguma entrada como essa. E nós realmente não sabemos quando vamos querer que isso pare. Agora, com certeza, este é um infinito, este é um bom exemplo de quando você gostaria de usar um loop while sobre um loop for é quando a condição que você deseja que seja atendida é mais complicada e você não sei a quantidade exata de vezes que você deseja percorrer o loop, certo? Porque normalmente com um loop for, você dirá que quando nosso iterador ou muita temperatura que você estava acostumado a I no passado como abreviação de iterador é menor ou maior que um certo número ou algo parecido. De qualquer forma, se formos em frente e digitarmos um número inteiro, como pedimos isso vai imprimi-lo e nos expulsar do nosso loop e estamos todos prontos para começar. Mas há outra maneira de fazer isso. Então, se você disser algo como CAN, aqui, aqui embaixo na declaração if, pode realmente dizer c n dot fail. No entanto, para o nosso bloco de código desenhado aqui, realmente queremos ver se ele não falhou. Poderíamos apenas dizer, se não falhar assim. E se executássemos nosso código. Você pode ver que isso funciona da mesma forma que antes. E se eu digitar um número inteiro, BAM, nos expulsa. Assim mesmo. Tudo pronto para ir. Então aí está. Você também pode usar o método CN dot fail para ver se essa operação falhou ou não. Então, se não quiséssemos fazer isso, basta cortar isso aqui, colar abaixo, cortar todos nós aqui, colocar em uma declaração if e remover isso. E isso funcionaria muito bem, desde que fizéssemos uma declaração de continuação aqui, certo? Então, toda vez que falhava, na verdade, simplesmente ignorávamos a condição do verificador, o que é verdadeiro e cumprido. E se não falhasse, bem, nós sairíamos dela. Então, para o meu código aqui novamente, vamos ver se pegamos alguma coisa. Eu só vou seguir em frente. Repita. Mas ainda estamos no nosso circuito, certo? Porque acabamos de ver que esse escuro contém uma declaração sobre a qual falamos em um vídeo anterior para revisar e verificar a condição dela e pular o resto do código. Mas se realmente digitarmos um número, aí está. Expulse isso exatamente como esperaríamos. Agora, bem rápido para aqueles que estão se perguntando, como vimos a palavra stream algumas vezes, estamos obtendo código do arquivo de cabeçalho iostream. Estamos falando sobre o tamanho do stream aqui. Se eu passar o mouse sobre C n e C out, todos eles vêm desse arquivo de fluxo. Então, o que é uma string? E não se preocupe, você realmente não precisa entender isso completamente neste curso. Eu só queria te dizer o que é isso. Agora, basicamente em C plus, plus, um stream é apenas um fluxo de caracteres que são transferidos entre o programa e a saída de entrada. E então nossa saída C e C n são o que estamos usando para interagir com a entrada e a saída. E quando temos isso aqui, esse é essencialmente nosso fluxo. Esses são nossos personagens que são transferidos entre o programa. E, como sabemos, eles só são transferidos para o programa quando pressionamos Enter e todo esse texto aqui, tanto a saída do código R quanto a entrada nossa. Portanto, o personagem está sendo transferido de um lado para o outro entre nosso programa e o usuário faz parte desse fluxo de entrada e saída. Então, quando dissemos Ei, queremos que nosso programa ignore o tamanho do fluxo bancário dos caracteres, o tipo ou, basicamente, diga qualquer coisa possível que eles poderiam ter digitado em nosso console aqui, vá em frente e ignore. E dessa forma, começamos do zero. Não precisamos nos preocupar com o erro voltando, etc. É basicamente isso. É assim que você valida a entrada do usuário essencialmente com essas duas linhas aqui. E certificando-se de que a entrada foi concluída. De qualquer forma, esqueça o vídeo. Vou recapitular rapidamente tudo o que acabamos de falar. Esse vídeo era novo. Então, primeiro, sabemos que podemos usar nossa declaração CN aqui diretamente em uma condição e ela retornará verdadeira se a inserção de qualquer coisa que o usuário digitou na variável bem-sucedida e falsa caso contrário , também aprendemos sobre o método de preenchimento de assentos e pontos, que retornará verdadeiro se essa operação falhar e falso se não, então aprendemos sobre esses dois métodos aqui. E lembre-se de que o cn dot clear aqui basicamente apenas limpa o erro que surge do usuário tentando inserir dados incorretos na variável. Depois, temos o método cin.ignore, que basicamente ignora a quantidade de caracteres que solicitamos até o ponto em que pedimos que ele pare, o que, nesse caso, é tudo o que o usuário digitado. E isso é só para evitar que o ar volte logo. Tudo bem, então espero que isso não seja muito complicado. Agora, como eu disse, não vou usar muito isso durante o curso, pois acredito que é um monte de código que meio que convolve um pouco os vídeos sobre um tópico específico. Mas nos casos em que eu tenho um programa completo, vou em frente e adicionarei isso apenas para mostrar que isso é algo que devemos fazer se estivéssemos pedindo opinião do usuário e para lembrá-lo de como para fazer isso e quando. De qualquer forma, espero que tenham gostado do vídeo. Obrigado por assistir, e nos vemos na próxima. 42. Capítulo 7 (Loops): Operador de resolução de escopo: Neste vídeo, falarei com vocês sobre o operador de resolução de escopo e o que esse operador é para acessar uma variável global com o mesmo nome, uma variável local. Então, de um modo geral, eu não recomendaria que você tivesse duas variáveis com o mesmo nome. Mas no raro caso em que você tenha isso por qualquer motivo, mostrarei como você pode acessar a variável global e a local separadamente. Mas, de um modo geral, eu não o recomendaria e recomendaria ter nomes de variáveis mais específicos. Então você sempre sabe exatamente com o que estava trabalhando. Porque apesar de estarmos vendo coisas como int x, por exemplo, se eu estivesse usando isso, o gráfico, a pontuação em um jogo de futebol, eu gostaria de chamar essa pontuação e não algo genérico como isso, onde eu não vou saber o que essa variável está segurando. Tudo bem, então vamos ver como usar o operador de resolução de escopo. Então, primeiro, normalmente, se tivermos duas variáveis o mesmo nome como essa e tentarmos executar nosso código, teremos um erro. E isso porque você tem duas variáveis com o mesmo nome. E se você olhar aqui embaixo, eu realmente recebi um erro que diz int x redefinição. Eu tentei encontrar a mesma variável duas vezes. No entanto, ele permitirá que você tenha duas variáveis com o mesmo nome. Se, por exemplo, um for global e o outro for local. E como você pode ver, se eu tentar executar meu código agora, ele funciona muito bem e não chegamos lá. Agora, e se eu quisesse acessar essa variável sobre essa variável ou vice-versa? Então, vamos separá-los com algum tipo de valor para que possamos ver qual deles estamos acessando. Esse valor é dez, e eu darei a ela uma variável local, um valor de cinco. Então vamos seguir em frente e dizer x, assim mesmo, e executar nosso código. E como você pode ver , imprime cinco. E isso porque, por padrão, você acessará a variável local. Mas com o operador de resolução de escopo, você pode acessar a variável global. Então, se eles o virem novamente, como fizemos antes e depois antes da nossa variável, se simplesmente colocarmos no Colin desse jeito e executarmos nosso código, você pode ver, então imprimimos cinco e também imprimimos fora dez. E isso porque essas duas colunas aqui são o operador de resolução de escopo que permitirá que você acesse a variável global versus a variável local. E isso é praticamente tudo o que há nisso. Portanto, se você fizer isso com duas variáveis com o mesmo nome, use dois pontos como operador de resolução de escopo para acessar a variável global. E você não faz nada diferente para acessar o local. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 43. Capítulo 8 (Números aleatórios): introdução a números aleatórios: Neste vídeo, apresentarei uma introdução aos números aleatórios na programação como um todo. E depois disso, no próximo vídeo, vamos realmente gerar números aleatórios dentro do intervalo desejado em C plus plus. Então, vamos começar. Primeiramente, quando quisermos gerar números aleatórios, você vai querer adicionar esses dois arquivos ao seu programa. Então, no topo, vamos dizer que a hashtag inclui dentro de um símbolo menor que e maior que. Vamos dizer C std LIB. E essa é apenas a biblioteca padrão C como acontece com outra abreviação de. E então, na próxima, faremos a mesma coisa, exceto que vamos colocar o tempo C. E este aqui é com o qual estamos trabalhando, tudo bem, então eu vou seguir em frente e mover isso para cá. Agora, quando se trata de números aleatórios na programação, porque os computadores simplesmente fazem o que lhes é dito você não pode realmente obter um número aleatório. Não é possível, independentemente de todos os programas e aplicativos que você já viu, na verdade não está gerando um número aleatório. No entanto, para o usuário, parece aleatório. E deixe-me explicar como isso funciona. Então, primeiro, existe uma equação muito complicada na qual você pode colocar um número para começar. E isso lhe dará o que parece ser um número aleatório com base no que você deu. No entanto, se você continuar dando o mesmo número, ele devolverá o mesmo número. Então, na programação, o que você realmente quer fazer é dar a essa equação um número diferente a cada vez. Então, se um usuário acredita que está sempre recebendo um número aleatório da maneira que fazemos, é dando essa equação a hora atual. E porque leva a data e a hora, esse número sempre será diferente. Em outra coisa que eu quero mostrar a vocês neste vídeo é algo chamado overflow. Então, primeiro, uma variável inteira tem isso como seu número máximo. E outra maneira de conseguirmos isso sem apenas lembrar e dizer int underscore max e apenas um aviso. Existem outras palavras-chave como essa que não falaremos neste curso. Então, se você estiver interessado, isso é algo que você sempre pode analisar. De qualquer forma, o que eu vou fazer aqui, digamos que x é igual a ponto e vírgula no final. E então vamos dizer x plus plus. Então, vamos adicionar um a isso e depois imprimi-lo. E para mostrar o que está acontecendo, vamos fazer o telefone. E esta é a linha CL. E então homens, assim, e isso nos dará o valor inteiro mínimo. Como você pode ver, eles são exatamente a mesma coisa. E a razão para isso é que, uma vez que um número inteiro, ele passa como valor máximo, faz algo chamado transbordamento, que é onde ele simplesmente volta para um valor mínimo. E então faremos a contagem regressiva a partir daí. Agora, o que temos para fazer disso um número inteiro sem sinal? Então, diríamos int max, e isso nos dará o valor máximo para um número inteiro não assinado. Em seguida, execute um programa, na verdade, mantenha um número positivo e volte para 0, já que esse é o intervalo mínimo para um int não assinado. De qualquer forma, eu só queria mostrar o que o overflow foi bem rápido e você entenderá a melhor ideia de por que mostrei isso no próximo vídeo. Além disso, é uma coisa boa para saber sobre o futuro. De qualquer forma, a principal coisa que eu quero que você tire deste vídeo é que números aleatórios e programas não são realmente aleatórios e eles são o que chamamos de pseudo-aleatórios, então eles simplesmente parecem aleatórios para o usuário. E o que realmente está acontecendo quando inserimos um número em uma grande equação que nos dá um número aparentemente aleatório. E ao mudar o que é esse número, podemos obter um número aparentemente aleatório a cada vez. E é por isso que inserimos a hora atual nessa equação porque ela usa a data e hora, fornecendo um número diferente. De qualquer forma, isso é tudo para este vídeo. Certifique-se de adicionar essas bibliotecas e vamos deixá-las aqui pelo resto do curso pois isso não fará mal a nada. Obrigado por assistir e nos vemos na próxima. 44. Capítulo 8 (Números Aleatórios): geração de números aleatórios: Neste vídeo, mostrarei como podemos obter números aparentemente aleatórios em C plus plus. Agora, simplesmente ignore essa linha de textos que eu tenho aqui, e eu vou te mostrar o que isso significa e um pouco. De qualquer forma, vamos criar um programa que simula o lançamento de um dado de seis lados dez vezes. Então, primeiro, o que vamos fazer é dizer que para int I é igual a 0, I menor que dez. Eu mais, mais. Assim mesmo. Dentro do nosso loop, vamos dizer CL, rand, tudo em letras minúsculas, abrir e fechar parênteses e colocar um ponto e vírgula no final. E o que isso faria era automaticamente nos dar um número aleatório entre 0. Então, número entre rand max. Agora, o rand max tem um valor mínimo de 32.767. Então, vamos obter essa variedade louca de números. Como eu disse, esse é o valor mínimo, não o máximo. Então, antes de executarmos nosso código, vamos seguir em frente e colocar todos nós em uma nova linha. Então vamos em frente e executá-lo. Como você pode ver, obtivemos dez números aparentemente aleatórios. No entanto, vamos tentar memorizar alguns deles. Portanto, este primeiro é para 1184676334. Esses são nossos três primeiros. E se executarmos um programa novamente, oh, você olharia isso? Temos exatamente os mesmos números. E se fizéssemos isso de novo, obteríamos os mesmos números novamente. E isso continuará acontecendo para sempre porque, como eu disse, não é realmente aleatório. E recebemos a equação sobre a qual falei no último vídeo, o mesmo número exato para começar todas as vezes. Então, eles obtêm mais números aparentemente aleatórios. Precisamos responder a um valor diferente na equação que nos dá um número aparentemente aleatório. Agora, para fazer isso, o que vamos fazer está no topo do nosso programa. E, a propósito, eles só vão querer fazer isso uma vez. Caso contrário, você não obterá números aparentemente aleatórios , como poderia. Você vai dizer essa vertente, toda minúscula. E então, entre parênteses, vamos dizer o tempo todo em minúsculas. E entre parênteses novamente, vamos colocar não. Você também pode ver as pessoas colocarem 0 e é essencialmente a mesma coisa. E se eu passar o mouse sobre ele, você pode ver, mas também é 0. E então, no final, colocaremos um ponto e vírgula, então o que isso fará é que, quando nosso programa for executado, colocaremos a hora e a data diretamente na equação que fornece use um número aparentemente aleatório. E então esse método aleatório aqui nos dará o resultado disso. Embora isso tenha nos dado dez números aparentemente aleatórios, o problema foi, como você viu, quando o chamamos novamente e iniciamos nosso programa completamente. Esses primeiros dez números eram sempre os mesmos. E poderíamos ter feito 100 números e refeito nosso programa. E eles teriam sido os mesmos 100 números. Novamente, mesmo que esses 100 números fossem diferentes. Então, agora, quando um programa é executado, porque ele vai usar a hora e a data em que o programa é iniciado pela primeira vez. A equação sobre a qual falei nos dará uma lista de números aleatórios aparentemente diferentes a cada vez, porque o tempo deve ser diferente toda vez que executamos nosso programa. Muito rápido, o que essa coisa faz como semente, a equação aleatória com um número. E você pode realmente colocar um número positivo aqui, como cinco. E isso vai funcionar. E como você pode ver, se eu executar nosso programa em números e mortos antes. Mas se eu executá-lo novamente, haverá os mesmos números. Então eu vou voltar aqui. Então, de qualquer forma, por que só queremos ter isso em nosso programa uma vez? E por que não o colocamos em nosso loop for? Bem, o problema é que seu computador lê tão rapidamente que, ao ter esse loop interno for, podemos potencialmente imprimir o mesmo número várias vezes porque teríamos o mesmo número exato semeado em nossa equação. Porque essa linha de código aqui, ela pode ter sido executada duas vezes durante o mesmo tempo exato e, portanto, os números não teriam sido tão aleatórios quanto poderiam ter sido se tivéssemos executado isso apenas uma vez no início do nosso programa. E como isso permitirá que você obtenha uma lista de números, você só quer fazer isso uma vez. E como eu disse, basta colocar isso no início do seu programa. Se você estiver tentando obter um número aleatório e estiver pronto. Podemos invocar isso quantas vezes quisermos. Como eu disse, quando podemos até mesmo aumentar isso se quisermos e executar nosso código, você pode ver que obtemos 100 números. E se olharmos para esses três primeiros e nós os memorizarmos bem rápido. Uma vez que pude novamente, você pode ver que eles não são mais os mesmos todas as vezes, que é exatamente o que queremos. Agora, como eu disse, estamos tentando criar um programa aqui, simula um dado de seis lados. E bem, esses números são insanos. Então, como podemos corrigir isso? Bem, lembre-se daquele operador de módulo sobre o qual falamos quando falamos sobre operadores matemáticos básicos. Bem, esse é um ótimo exemplo de quando isso será útil. Então, o que vamos fazer é contornar nossa chamada aleatória de método aqui. E, como eu disse, entraremos em chamadas de métodos mais tarde no curso. Vamos seguir em frente e colocar parênteses. Assim. E então aqui, vamos colocar o operador de módulo seguido pelo número que queremos, então, sexo. E agora sabemos que só podemos obter um valor entre 05 porque esse operador, se você se lembrar, nos dá o restante desse número dividido por esse número. Mas se estivermos tentando simular o lançamento de dados, provavelmente quereremos um número entre 16 e não de 0 a cinco. E bem, não é um problema. Porque depois, digamos mais um, sem mais nem menos. Agora vamos pegar de um a seis. E se executarmos nosso programa, aí está. 12345678910, números aparentemente aleatórios entre 16. E podemos executar isso quantas vezes quisermos. E, como você pode ver, eles parecem estar sempre aleatórios. Então aí está. Essa é a maneira mais fácil de obter números aparentemente aleatórios dentro do intervalo que você deseja. Então, mais uma coisa que quero abordar é que, dependendo do que estamos usando, esse número aleatório quatro, há uma chance de que, dependendo do número, cometamos um erro. E pode ser difícil para nós fazer com que esse número apareça novamente, especialmente dependendo do alcance que obtemos dele. Então você pode, na verdade, economizar esse tempo, nenhum valor em algum lugar, e depois imprimi-lo para que no momento em que você entrar no ar, você tenha esse valor para entrar em seu programa. Então, o que poderíamos fazer é dizer algo como não assinada essa semente e igualá-la ao tempo. Assim mesmo. Você também pode ver isso chamado de tempo 0. Isso faz exatamente a mesma coisa. Não há diferença entre essa linha aqui e esta. Então, se você vê isso agora, a mesma coisa. E então aqui embaixo, podemos ir em frente e colocar. Então, poderíamos dizer que C out Seed criou uma linha. Agora, se executarmos um programa, o que você pode fazer, se você recebeu algum tipo de erro ao executar seu programa aqui, você pode copiar esse número exato voltar ao seu programa. E vou deletar isso aqui rapidamente. E onde temos ESR e aqui você pode simplesmente inserir o mesmo número exato que tínhamos. E porque isso precisa de um valor inteiro não assinado e não de um inteiro para um atrás head e capture essas duas enzimas. Assim. Aí está você. Agora podemos obter o mesmo número todas as vezes que recebemos quando tivemos nosso erro e diagnosticá-lo dessa forma. Para que seja apenas algo que você deve ter em mente , talvez queira uma maneira obter o valor que foi inserido em seu programa. Se você já jogou algum tipo de jogo como Minecraft ou algo parecido, em que eles geram números aleatórios e fornecem uma semente que permite que você obtenha mesmo mapa novamente. Bem, aí está. Isso porque essa geração de mapas não é realmente aleatória. E você pode simplesmente colocar esse mesmo valor de volta na equação e obter o mesmo mapa novamente. E aí está. É assim que você obtém números aleatórios em C plus plus. E agora você também sabe como obter o mesmo conjunto de números aleatórios se usar suco. De qualquer forma, espero que você tenha achado este vídeo útil. Obrigado por assistir, e nos vemos na próxima. 45. Capítulo 9 (recipientes): introdução de recipientes: Neste vídeo, vou falar com você sobre contêineres. Um contêiner é essencialmente apenas um objeto que contém outros objetos e os objetos que ele contém, ou geralmente chamados de seus elementos. Outra coisa sobre os contêineres é que eles têm muitas funções que você pode usar para trabalhar com todos os elementos dentro deles. Agora, existem vários contêineres diferentes no C plus plus. E neste curso , vamos examinar apenas alguns deles. Mas eu recomendo fortemente que você procure todos os diferentes contêineres e, pelo menos veja o que eles fazem para que, você sabe, estejam disponíveis para você, caso você precise deles. Além disso, abordaremos apenas algumas funções e nossos métodos para cada tipo de contêiner que abordaremos. Então, mais uma vez, se você quiser saber mais sobre eles, eu recomendo pesquisar as diferentes funções disponíveis para que você também possa ver o que está disponível para isso. Agora, ao decidir qual contêiner você deseja usar para seu projeto, você não deve apenas escolher um com base em quão bem ele lida com o trabalho em todas as suas diferentes funções, mas também com base nas próprias funções. Como cada um terá algo, eles podem fazer um pouco diferente do outro. É, como eu disse, que você quer escolher com base na rapidez com que cada um faz, uma tarefa ou outra, bem como na funcionalidade que está disponível para ele. E para aqueles que vêm de outra linguagem de programação, vocês também podem ter visto essas chamadas de coleções. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 46. Capítulo 9 (recipientes): matrizes: Neste vídeo, falaremos sobre matrizes. Agora. As matrizes são o primeiro contêiner sobre o qual falaremos neste curso e geralmente são consideradas um dos tipos de contêineres mais básicos que você também verá em outras linguagens de programação. Então, em primeiro lugar, matrizes são basicamente apenas um grupo de elementos do mesmo tipo armazenados em sequência. E eles também permitirão que você acesse vários elementos usando o mesmo identificador. Lembre-se de que um contêiner é basicamente algo que contém vários objetos. E os objetos dentro desse contêiner são chamados de elementos. Então é daí que essa palavra vem daí. Então, vamos dar uma olhada na sintaxe básica de uma matriz. Então, primeiro você terá o tipo de dados seguido pelo nome, seguido por colchetes abertos e fechados. E então você terminará com um ponto e vírgula. E então, dentro desses colchetes, você terá o tamanho de uma matriz. Agora, ao criar e usar uma matriz, você começou a saber o tamanho ou quantos elementos deseja armazená-la nessa matriz, pois é realmente ineficiente mudar isso. Então, vamos prosseguir e criar uma matriz básica de números inteiros. Então, para fazer isso, vamos seguir em frente e dizer olá para comprar uma matriz int como esta. E então, dentro desses colchetes, daremos um tamanho de cinco, por exemplo. E então colocaremos um ponto e vírgula no final. Então, isso aqui vai criar uma matriz int chamada matriz int com cinco números inteiros nela. E podemos dar a isso o nome que quisermos. Eu decidi chamá-lo de int array por uma questão de simplicidade. Agora, observe que se eu passar o mouse sobre isso, ele diz que eles não foram inicializados. Isso significa que eles ainda não têm um valor inicial. E há algumas maneiras de seguirmos em frente e oferecer uma. Então, o primeiro seria colocá-lo antes do ponto e vírgula. Até agora, acabamos de declarar essa matriz, mas não fornecemos nenhum dos números inteiros nela e o valor inicial. Então, depois disso, podemos dizer iguais e , em seguida, abrir e fechar colchetes, assim, notei que essas linhas pontilhadas desapareceram na minha tela aqui. E agora, cada número inteiro em nossa matriz tem um valor de 0. Então, essa é uma maneira. Você pode dar a cada valor inteiro 0, mas também podemos fornecer a eles um valor exato e valores diferentes dentro desses colchetes. Então, para fazer isso, podemos simplesmente dizer algo assim, onde você escolheria cento e vinte e dois, vinte e um e setenta e seis ou algo assim. Então, agora todas as nossas cinco variáveis inteiras em nossa matriz int têm um valor inicial que definimos. Então, o primeiro será para, o segundo será um e assim por diante. Além disso, em C plus plus, você pode simplesmente remover esse sinal de igual e ele será exatamente o mesmo que se o tivéssemos lá. Pessoalmente, gosto de tê-lo lá, pois já usamos o operador de atribuição aqui para inicializar coisas como variáveis e coisas assim. Mas como eu disse, você pode retirá-lo. Então, ele vê o código de alguém sem isso, você sabe que é exatamente o mesmo que com ele. Agora, e se quiséssemos ir em frente e imprimir que todos os filos são números inteiros? Como podemos acessá-los? Bem, vamos seguir em frente e criar um loop for. Então, vamos dizer quatro e depois diremos int I é igual a 0, I menor que cinco, I mais, mais. E então, dentro do nosso bloco de código aqui, vamos dizer C0, eu direi matriz int, porque esse é o nome da nossa matriz, seguido por colchetes abertos e fechados e um ponto e vírgula no final. E então, dentro daqui, precisamos colocar o índice do que queremos imprimir. E porque já temos um iterador que vai de 0 a quatro. Vamos apenas colocar. Agora, para mostrar o que os índices são adequados. A forma como as matrizes funcionam como essa primeira variável inteira, NRA, está no índice 0. Então, se eu quisesse imprimir este, eu colocaria 0 aqui assim, e então ele vai 01234, etc. Então vamos em frente e colocaremos um I. E depois disso, vamos em frente e jogar uma companhia aérea e execute nosso código. E como você pode ver, imprimimos de 41520 a 121 em 76, bem, e para mostrar que tudo isso tem um valor inicial de 0 sem nada aqui. Se executarmos nosso código sem nada lá, eles imprimirão 0. Tudo bem, agora vamos dar uma olhada na outra maneira de inicializar os valores em nossa matriz. Então, vamos em frente e nos livrar desses iguais e dos colchetes encaracolados aqui. E da mesma forma que acessamos os valores em nossa matriz para imprimi-los. Também podemos acessar os valores para inicializá-los. Então, podemos dizer int array. E então, entre colchetes, poderíamos colocar 0, por exemplo. Basta dizer que é igual ao que quisermos, desse jeito. E depois coloque um ponto e vírgula no final. E isso vai funcionar muito bem. Poderíamos fazer isso se quiséssemos usar 1234 e obter um valor diferente para cada um deles. Tudo bem, se executarmos um código, você pode ver que isso funciona muito bem. E nós fomos 01234. Poderíamos ter feito isso em qualquer ordem, se quiséssemos. Agora, digamos que quiséssemos obter tudo isso o mesmo valor exato de, digamos, 30. E digamos que tivéssemos muito mais do que cinco e nossa matriz. Então, digamos que temos 100 deles. Bem, em vez de fazer isso, o que nos levaria para sempre, podemos simplesmente ir até aqui. Então eu tenho menos de 100. E então aqui embaixo, adicionaremos outra linha acima, onde estamos imprimindo nossos valores de matriz e digamos matriz int. Vou usar i para índice mais uma vez aqui, e diremos que é igual a 30. E agora ele será impresso 3000 vezes. E eu não vou contar isso, mas confie em mim, há 100. Tudo bem, então existem diferentes maneiras de inicializar suas matrizes. Além disso, também podemos definir a variável igual ao valor dentro de uma matriz, se quisermos. Então, podemos dizer que x é igual int array e, em seguida incluir um índice como to, por exemplo. E se fôssemos imprimir assim, eu vou comentar esta linha. Então você pode ver que isso está funcionando, já que há uma tonelada de 30 anos lá e aí está. Então aí está. Agora você sabe como trabalhar com matrizes. Agora, quando você quiser usar uma matriz, bem, primeiro, lembre-se de que o tamanho de uma matriz é fixo. Então você precisa saber o valor exato, mas você vai investir nele. E eu posso te mostrar isso fazendo o seguinte. Então, se seguirmos em frente e apagarmos aqueles aqui e dissermos que x é igual a 100, e então tentarmos colocar x aqui para o tamanho da nossa matriz. Você pode ver que recebemos um erro porque ele precisa ser um valor constante que não pode mudar. Agora, poderíamos fazer disso uma constante e isso funcionaria muito bem. Mas observe que o tamanho da sua matriz precisa ser conhecido com antecedência. Além disso, eles são eficientes para recuperar os valores deles , como fizemos aqui quando os imprimimos. E eles são ótimos para quando você deseja colocar os elementos em sua matriz em ordem, como fizemos aqui também. Agora fui evitar usá-los. Bem, você deve evitá-los quando quiser inserir ou remover elementos da matriz, porque, como eu disse, eles têm tamanho fixo. Então, se você não vai saber o tamanho ao iniciar o programa, isso é um problema. E um bom exemplo de quando você não gostaria de usar o I'm I'm, certo? De qualquer forma, isso é tudo para este vídeo. No próximo vídeo, falaremos sobre algo chamado matriz multidimensional. Então, obrigado por assistir, e nos vemos na próxima. 47. 46: Neste vídeo, falaremos sobre matrizes multidimensionais. Agora, a melhor maneira de provavelmente pensar matrizes multidimensionais como matrizes de matrizes. Além disso, uma matriz multidimensional pode ter quantas dimensões você precisar ou desejar, mas esteja ciente de que a memória usada aumenta drasticamente com cada dimensão adicionada. Então, isso é algo que você deve conhecer. Então, eu tenho um exemplo de uma matriz bidimensional aqui para você, que será criada aqui em um minuto. Então, para a matriz 2D, você terá seu tipo de dados, seu nome como antes. Mas agora, em vez de apenas um conjunto de colchetes, você terá que, se quisesse fazer uma matriz tridimensional, você teria um terceiro conjunto de colchetes e assim por diante. E então você precisa do tamanho para cada uma dessas dimensões. E eu apenas coloquei linhas e colunas para ajudá-lo a visualizar como isso seria se você visualizasse isso como uma grade 2D onde você tem linhas e colunas, e você pode visualizar os elementos de um matriz bidimensional com três linhas e três colunas sendo visualizadas como tal. Agora, para realmente acessar cada um desses elementos, estaríamos fazendo o que está aqui de acordo. Portanto, esse primeiro será 000102. Em seguida, vamos descer para a linha um, coluna zero, porque lembre-se, os índices começam em zero quando se trata de contêineres. Então, isso será 10111220, t1, t2. Tudo bem, então vamos criar isso e imprimi-lo como se estivesse aqui. Ok, então o que vamos fazer é dizer, vou dizer mais matriz de tipos. E então, entre colchetes aqui, vamos dizer três depois disso. E diremos três novamente. Vou colocar um ponto e vírgula no final. Além disso, podemos prosseguir e inicializar nossa matriz multidimensional forma semelhante à que fizemos uma matriz regular. Então, podemos dizer algo como iguais e, em seguida, ter dois colchetes curvos assim. E tudo isso será inicializado em zero. Além disso. Podemos fazer isso de outra forma, inserindo um valor diretamente. Então, se quiséssemos que os valores fossem mais ou menos assim aqui, poderíamos dizer uma vírgula dois, vírgula três, assim. Em seguida, crie outro conjunto de colchetes encaracolados para a próxima linha. Você poderia dizer 456 e depois fazer isso de novo. Então sete, nove. E agora, a última coisa que precisamos fazer para que isso funcione é colocar tudo isso e outro conjunto de colchetes encaracolados. Então, vamos fazer isso. E também precisamos colocar uma vírgula entre cada conjunto. Então, assim mesmo. E se você achar que é mais fácil de visualizar, você pode fazer algo assim. Mas de qualquer forma, vou seguir em frente e colocá-los de volta ao que eram. Em seguida, vamos continuar e realmente imprimir todos os valores e uma matriz multidimensional. Mas antes de fazermos isso, vou mostrar uma última coisa que esqueci de mostrar no último vídeo, e mostrarei como ela também funciona com uma matriz multidimensional. Então, caso você se depare com isso, como eu normalmente não recomendaria fazer isso porque você pode encontrar alguns problemas inesperados, você pode dizer int minha matriz, por exemplo, daremos a isso um tamanho de nada. E então podemos dizer igual e, em seguida, inicializá-lo em nossos colchetes, assim. E isso realmente funcionará muito bem. E ele saberá automaticamente que será do tamanho de quatro. Agora, você pode fazer o mesmo aqui, mas só pode remover esse primeiro valor. Então, nesse caso, seria como remover a quantidade de linhas, que será calculada pela quantidade de conjuntos de colchetes ondulados que temos. Em seguida, a quantidade de colunas que você precisa especificar, porque isso não funcionará. Como você pode ver, recebemos imediatamente um erro, certo? Então, eu só queria te mostrar isso rápido. Depois do tamanho, volte lá explicitamente também. Então, vamos continuar e realmente imprimir nossa matriz aqui de uma forma parecida com esta. Então, faça isso, vamos criar dois loops para que digamos que nossos zeros são menores que três, r mais mais. E então aqui dentro, vou adicionar outro for-loop e dizer que int c é igual a zero, menos de três, C mais, mais. E criaremos colchetes encaracolados assim. E então vamos imprimir os valores. Então, vamos dizer C para fora. Tudo bem? E então, entre colchetes aqui, vamos colocar R e em vez disso , somos outros colchetes. Depois disso, imprimiremos um espaço em branco como esse. E então, abaixo desse para loop, dentro do nosso outro, vamos criar uma linha em branco. Além disso, só para avisar, esses acessos de Hollywood inicializam e editam qualquer um dos valores e nossa matriz multidimensional. Então, antes de onde digitávamos o nome da matriz seguido pelo índice do elemento. Aqui, nosso índice seria mais ou menos assim, como mostrei anteriormente. Então, o que vai acontecer é que vamos passar pelo nosso primeiro loop for. E eu chamei essa variável de são abreviações de linhas, mas você pode chamá-la como quiser. Então, a primeira vez em R será igual a zero e c será igual a zero. Então, ele vai obter o índice 00 e imprimir um porque é isso que temos, certo? E então ele voltará a esse loop novamente e imprimirá dois e depois três. E então uma galinha estava de volta, as fileiras mudarão para uma. Então, vamos estar às 01:01, 112, etc. Então, vamos executar isso e eles imprimem. 123, McDonald linha 456, e descendo a linha novamente, 789. E aí está. Agora, também poderíamos ter criado um loop for duplo como esse para inicializar todos esses valores de um a nove, como fizemos aqui. Então, vamos ver como seria se fôssemos em frente e copiássemos esses duplo por loop e colássemos aqui, observe que não recebemos nenhum erro porque ambos ambos são locais para seu bloco de código específico e não existem fora dele. Ter arte aqui e C aqui, e R aqui, e ver aqui, não causa nenhum problema. Então, vamos prosseguir e remover nossa inicialização inicial aqui. Mas podemos prosseguir e inicializar todos eles para zero. Isso é bom. E então, abaixo disso, diremos que int I é igual a um. E então aqui vamos dizer que, em vez de imprimir isso, diremos RNC de várias taxas, como antes. Mas, em vez disso, vamos dizer iguais. E logo abaixo, dirá I plus plus, para que aumente em um a cada vez. Tudo bem, agora, vamos executar nosso código. Como você pode ver, tudo foi inicializado, muito bem. E a única razão pela qual isso realmente está abaixo de algumas linhas aqui, só porque deixamos para eles a nova linha. Mas, como você pode ver, da mesma forma que conseguimos imprimi-las em ordem usando esse loop duplo. Conseguimos inicializá-los em ordem usando um loop duplo for, certo? Porque é basicamente a mesma coisa. Mas, em vez de apenas imprimi-lo, demos a ele um valor inicial, apenas aumentando I em um toda vez que eles dão a eles um valor em ordem. E embora realmente tenhamos tudo isso cortado, posso mostrar como podemos criar rapidamente uma tabela de multiplicação e se quisermos. Então, vamos em frente e alterá-los para dez, por exemplo, ou podemos até mesmo fazer algo como, digamos, algo como 30. E então aqui embaixo mudará, subiu para 34, nosso valor r. E ambos, e o mesmo com nosso próprio valor. E vamos começar os dois em um em todos os casos aqui. Então, como estávamos fotografando os dois ao mesmo tempo, se realmente quiséssemos que a tabela tivesse 30 dígitos completos, gostaríamos de alterá-los todos para 31, assim. Então, aqui, vamos remover esse I plus, plus. E então, definindo-o igual a i, vamos dizer R vezes C, assim mesmo. Agora podemos remover o coração e eu vario inteiramente. Tudo bem, então agora criamos uma matriz multidimensional de tamanho 31. Em seguida, criamos um for-loop com uma variável inteira que começa em um e continua viva enquanto for menor que 31. E aumentamos nosso em um a cada vez, então fazemos a mesma coisa com C aqui embaixo. Então colocamos r e c para nossos índices aqui e apenas definimos o índice igual a R vezes C. E então vamos remover isso, a declaração de linha aqui. Mas vamos deixá-lo na que está aqui embaixo. Então, em vez de apenas colocar um único espaço em branco aqui, vamos colocar uma aba. E uma maneira fácil de fazer isso seria colocar uma única citação como essa ou um conjunto de aspas simples, devo dizer. Em seguida, use a barra invertida em t, o que criará uma aba. A propósito, sempre que você tiver a barra invertida e um caractere, Let's pode ser considerado apenas um único caractere para um caractere. Tudo bem, então eu vou correr muito bem. Agora, vamos prosseguir e executar nosso programa. E, como você pode ver, isso é realmente muito grande. Vamos seguir em frente e reduzir isso para algo como 11 para cada um deles. E execute nosso código novamente. E eles vão 1-1012 vezes dois vezes dois é quatro. E se olharmos aqui, seis vezes 636, etc., e agora criamos nossa própria tabela de multiplicação com apenas alguns loops for-loops e uma matriz multidimensional. Então, é muito legal de qualquer maneira, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 48. Capítulo 9 (recipientes): vetores: Neste vídeo, falaremos sobre vetores. E você pode pensar nos vetores como essencialmente uma matriz redimensionável com alguma funcionalidade extra. E isso porque há várias funções ou métodos extras associados a eles. E eu vou te mostrar alguns deles aqui neste vídeo. Mas se você quiser ver todos os métodos ou funções possíveis, eu recomendo que você os procure , pois existem muitos deles. Agora, bem rápido, fui em frente e coloquei de volta aqui a sintaxe de uma matriz. Então, se você se lembrar, vamos colocar o tipo de dados, o nome e, em seguida, o tamanho e alguns colchetes. No entanto, a sintaxe de um vetor é um pouco diferente. Então, vamos dizer vetor e todos em minúsculas seguidos pelo tipo de dados intermediário, um símbolo menor que e maior que. E por fim, teremos o nome seguido por um ponto e vírgula no final. Agora, antes de darmos uma olhada em como criar e usar um vetor próprio, precisamos adicionar outro arquivo de cabeçalho na parte superior do nosso código aqui. Então, vamos dizer que a hashtag inclui. E então, entre o símbolo menor que e maior que, vamos dizer que leitor, assim mesmo, agora terá acesso a tudo o que precisamos. Então, vamos seguir em frente e começar. Primeiramente, vamos dizer vetor. E então, entre o símbolo menor que e maior que, teremos nosso tipo de dados seguido pelo nome, e chamaremos isso de meu vetor, assim mesmo. E dentro daqui, assim como com outros contêineres, você colocará uma infinidade de tipos de dados. Até agora, usamos números inteiros, mas, nesse caso, por que não colocamos sequências de caracteres? Ok, então vamos dizer string, e em vez de chamá-la de meu vetor, por que não chamamos isso de mochila, assim. E então, assim como poderíamos com matrizes, podemos realmente ir em frente e imediatamente colocar alguns elementos em nosso vetor aqui, aqui, poderíamos dizer igual e depois entre colchetes. Agora, observe aqui que não temos o tamanho do nosso vetor e isso porque eu disse que ele é redimensionável. Basicamente, é um tamanho dinâmico, o que significa que pode mudar à medida que nosso código é executado. Então, aqui, podemos dar a ele um tamanho padrão adicionando alguns valores padrão. Então, vamos fingir que estávamos enchendo uma mochila aqui. Então, vamos colocar algumas cordas. Então, poderíamos dizer algo como livro, Kama, lápis. E também adicionaremos um bloco de notas. Ok, agora, obviamente, essas são palavras arbitrárias e apenas, mas você tem a ideia aqui embaixo. Na verdade, podemos imprimir coisas do nosso vetor da mesma forma que faríamos com uma matriz. Então, podemos simplesmente dizer mochila e, em seguida, abrir e fechar os colchetes internos. Colocaremos o índice e o índice funcionará exatamente da mesma forma que com matrizes, onde é 012. Então, dissemos biotecnologia um e queríamos imprimi-lo. Nós diríamos C out mochila 1, assim. E se eu executar meu código aqui, você pode ver que ele diz lápis porque essa é a string em nosso primeiro índice aqui ou no índice um. Agora, o interessante sobre vetores em comparação com matrizes é que, como eu disse, é um tamanho dinâmico. Na verdade, podemos adicionar coisas a isso e elas serão adicionadas no final. Além disso, como eu disse no início, existem algumas funções ou métodos extras associados a vetores que podemos usar. Vamos dar uma olhada em um desses agora também. Então, aqui embaixo, podemos dizer mochila ou o símbolo do período. Você verá uma lista de opções aqui, pelo menos um pouco do Visual Studio. Mas, na verdade, vamos digitar o tamanho e depois abrir e fechar parênteses e um ponto e vírgula no final. O que isso vai fazer é nos dizer o tamanho exato do vetor da nossa mochila. E se quiséssemos, poderíamos gastar isso também. Eu digo “C” antes disso, sem mais nem menos. E vamos seguir em frente e lançar uma nova linha aqui. Há um prazo para isso, só para que não esteja na mesma linha que este. E agora, quando nosso código for executado, ele imprimirá um lápis. Nesse caso, pelo menos. E então, aqui, ele imprimirá o tamanho. E ao contrário dos índices em que vai de 012, o tamanho vai ser 123, assim como você esperaria quando ele quisesse saber o tamanho de algo, eles saberão exatamente quantos itens estão nele. Portanto, deve imprimir três. E se executarmos nosso código aqui, você pode ver que é isso que ele faz. Imprimimos a lápis e, em seguida, em uma nova linha, imprimimos três. Então, como realmente adicionamos itens ao nosso vetor? Bem, se formos até aqui, podemos simplesmente gravar nela de volta para que ela saiba a que estamos nos referindo ou com o que estamos querendo trabalhar, que seria uma mochila neste caso. E então vamos dizer ponto e ver esse método de resistência aqui. É isso que vamos digitar. Vamos dizer “empurre” e o placar recue. E então, entre parênteses, vamos colocar o que queremos adicionar ao nosso vetor. Então, vamos colocar o valor que queremos adicionar, assim como colocamos um lápis no Bloco de Notas aqui em cima, adicionar outra string, já que nosso vetor é feito de cadeias de caracteres. Então, aqui, vamos pegar algo como thriller e colocar um ponto e vírgula no final. E agora a régua estará no índice três porque temos 012 e , em seguida, estamos adicionando essa. Então, isso seria três. E aqui embaixo dizemos CL mochila três. E vamos nos certificar de que foi colocado em uma nova linha. Então, vamos apenas dizer a linha M assim e executar nosso código. Você pode ver isso como o lápis estojo. Aparece, imprimiu três, adicionou uma régua e depois imprima o que estava no índice três. Agora, aqui, é muito fácil dizer que esse item de régua que acabamos de adicionar está no índice três, dizendo que tudo está aqui no FBI, aqui na nossa tela. Mas e se quiséssemos apenas imprimir o último item em nosso vetor? Mas não sabíamos exatamente qual era esse índice. Bem, como temos esse método de tamanho, podemos usar que nos dirá o tamanho exato dele. Na verdade, poderíamos dizer o tamanho dos pontos da mochila. Depois disso, precisamos dizer menos um. Agora, a razão pela qual temos esse menos um aqui é porque, embora nossa mochila ou um tamanho vetorial se garfo, temos quatro itens aqui, ela não tem um índice de quatro porque é 0123. E se quisermos acessar o valor real aqui e imprimi-lo, em vez de apenas imprimir três aqui, colocaremos isso entre colchetes após o nome do nosso vetor, assim como faríamos se estivéssemos tentando acessar qualquer outro valor aqui. Vamos cortar isso. E diremos mochila entre colchetes. Vamos colar isso assim. Agora ele vai imprimir qual é o índice quatro da mochila menos um ou qualquer que seja o tamanho máximo menos um, que sempre será o último item da nossa, ok, então é assim que você pode obter o último item, você deveria precisar disso? E se executarmos nosso código aqui, você pode ver o trigo que, na verdade, imprime uma régua. Agora também podemos remover itens do nosso vetor e eles serão removidos na mesma ordem. Assim, assim como ele o adiciona ao final do nosso vetor, podemos remover coisas do final do nosso vetor. Então, bem rápido, vou retirar essa mochila. Uma linha que temos aqui, então criamos uma mochila. Imprimimos o tamanho, que neste caso é três. Adicionamos um item, imprimimos qual é o nosso último item e , na verdade , removeremos esse último item. Então, aqui embaixo, vamos dizer essa operação, sublinhá-la novamente. Tudo em letras minúsculas, parênteses abertos e fechados e um ponto e vírgula no final. E o que isso vai fazer é tirar o último item do nosso vetor. Então, se copiarmos nossa impressão do último item aqui e colarmos isso abaixo e o que não é revestimento, você pode ver que, bem, criamos uma nova linha primeiro, depois imprimimos três porque é o tamanho do nosso vetor. Em seguida, adicionamos um item de régua, imprimimos o último item sendo a régua dizendo que acabamos de adicionar isso e depois nos livramos da régua. Então, agora nosso último item é o Bloco e também o imprimimos. Então aí está. Agora você sabe como criar e usar a. E esses três métodos aqui, sendo o tamanho, o pushback e o método pop back, são provavelmente os três métodos e funções OR mais comuns que você usará quando se trata de vetores. Então, quando você quer usar um vetor? Bem, quando você quer que um monte de dados sejam armazenados em ordem, exatamente como era com uma matriz. E quando você não sabe o tamanho no momento da compilação ou quando executa seu código. Então, não sabíamos qual seria o tamanho e não precisávamos inserir um tamanho como fizemos com uma matriz. Só foi capaz de mudar dinamicamente à medida que nosso código era alugado. Então, se isso é algo que você precisa, você pode considerar o uso de um vetor. E se você planeja adicionar e remover elementos do final do contêiner que está usando , um vetor é outra boa opção porque, como você viu aqui, existe um método para isso. E como nossas informações são armazenadas em ordem, poderíamos ter repetido isso e impresso tudo da mesma forma que poderíamos com nossa matriz. Agora, quando você não gostaria de usar um vetor? Bem, se você está tentando adicionar ou remover elementos na frente do vetor, ou seja, aqui onde o livro estava no índice 0 ou em algum lugar no meio. Especialmente se você tiver muito mais itens aqui, isso provavelmente não é para você. Além disso, se você já sabe o tamanho do contêiner e isso não vai mudar. Pode muito bem usar apenas uma matriz. Agora está escuro aqui. Vamos imprimir tudo em nosso vetor apenas para mostrar mais um pequeno truque que podemos fazer com um vetor por causa dessas funções extras. Então, aqui, eu vou dizer que para int I é igual a 0, eu é menor que o tamanho da mochila. Então eu, mais, mais e abaixo disso, em colchetes encaracolados simplesmente vou dizer mochila. E depois colchetes. Vamos dizer oi e, depois disso, criaremos uma nova linha como essa. E agora vai imprimir tudo na mochila dela, independentemente de quantos itens estejam em nosso Peck, Peck, certo? Porque agora é dinâmico com base no tamanho. E então vamos remover tudo aqui em cima, assim como antes, nosso loop for e executar nosso código. E como você pode ver, imprimimos livro, lápis e caneta. E mesmo se mudarmos nosso tamanho aqui, e pudéssemos fazer isso aqui em cima, ou poderíamos fazer isso usando nossa função de retrocesso novamente. Então, vamos dizer que a mochila dot push back. Então, entre parênteses, dirá algo como dezenas. E então, se executarmos nosso código sem alterar nada aqui, você pode ver que agora imprimimos canetas. Então aí está. Há apenas outro caso de uso para o método de tamanho. E outro motivo pelo qual você pode querer usar um fator para a funcionalidade extra sobre a qual falamos no início. E isso porque, como você pode ver, podemos mudar nosso vetor aumentando o tamanho e diminuindo o tamanho. E nosso for-loop nunca precisa mudar. E antes que eu esqueça, vamos deixar esse arquivo de cabeçalho vetorial e nosso código de agora em diante junto com o resto deles. E vamos continuar fazendo isso daqui em diante. Sempre que adicionarmos um arquivo de cabeçalho, vamos deixá-lo, a menos que seja indicado o contrário. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 49. Capítulo 9 (recipientes): filas: Neste vídeo, falaremos sobre filas. Agora, uma fila é outro tipo de contêiner. Eles costumam dizer o tipo de acordo “ primeiro a entrar, primeiro a sair”. Então, basicamente, o que quer que estivesse na frente da fila, ele sairia da fila primeiro. E você pode pensar nisso como fazer fila para chegar ao caixa uma mercearia ou algo parecido. Quem chegar lá primeiro vai sair primeiro. Então, primeiro a entrar, primeiro a sair. Agora, a sintaxe para isso é muito semelhante à sintaxe de um vetor que acabamos de ver no último vídeo. Mas em vez de dizer vetor, vamos dizer fila. Mais uma vez em letras minúsculas. No topo aqui, vamos incluir também o arquivo de cabeçalho. E isso só vai ser chamado de fila e certifique-se de mantê-la lá pelo resto do curso. Então, no topo aqui, diremos que a hashtag inclui assim. Agora, vamos criar e trabalhar com acute. Então, para este exemplo, vamos apenas criar uma fila de números inteiros. Aqui. Vamos dizer Q e, em seguida, R digite dados com o símbolo menor que e maior que. Então, diremos que, depois, daremos um nome a isso. Por que não chamamos isso de algo como resultados de questionários. Ok, então vamos em frente e, na verdade , adicionar alguns números inteiros ao cubo r. Então, aqui embaixo, para fazer isso, precisamos dizer o nome da nossa fila para que ela saiba do que estamos falando em primeiro lugar. Não queremos dizer ponto, apertar e entre parênteses, basta colocar o que queremos adicionar em ponto e vírgula sem fio no final e dizer algo como 100. E vamos adicionar mais algumas que podemos colocar em qualquer número que você quiser. Como. Então, com uma fila, se quisermos imprimir algo, digite q, na verdade não podemos fazer. Nós temos no passado, então não podemos dizer a pontuação do questionário. E então, entre colchetes, digamos dois, por exemplo, com um ponto e vírgula no final é que isso não funciona. E você pode ver aqui, e se eu tentasse dizer C aqui, isso não nos permitiria fazer isso, teremos um erro. Então, como fazemos isso? Bem, se você quiser pronunciar toda a sua fila, você fará o seguinte. Então, primeiro, vamos criar um loop while e depois vamos colocar o símbolo não e nossa condição aqui, seguido pelo nome da nossa fila, pelas pontuações do questionário. E então vamos dizer morrer, vazio, tudo em letras minúsculas com parênteses abertos e fechados, assim. Então, o que estamos dizendo aqui é que, embora pontuações do questionário sejam nosso q, não estão vazias, então esse vazio retornará verdadeiro se estiver vazio e falso se não estiver vazio. Mas se você se lembrar, porque temos esse nó aqui, terá o efeito oposto. Vestindo-se bem, os resultados do questionário não estão vazios. Queríamos fazer o seguinte. E o que queremos fazer é imprimir o que está na frente da nossa fila. E se você se lembrar, o contêiner Q usa o primeiro a entrar, o primeiro a sair. Então, porque se olharmos aqui, 100 foi o primeiro, será o primeiro que imprimiremos. E para fazer isso, vamos simplesmente dizer CL. E depois vamos dizer os resultados do questionário. E isso vai imprimir o que está na frente da fila. Isso era apenas parênteses abertos e fechados, como esse em um ponto e vírgula no final. Então, o que esse método frontal faz aqui é retornar o valor na frente da fila. E também há um método de backup para obter o que está no final da fila. Mas se quisermos conseguir tudo, não apenas pela frente ou por trás, tudo o que está no meio, na verdade teremos que começar a removê-los. Então, como eu disse, você pode pensar que uma fila está entrando na fila em algum lugar. A primeira pessoa vai para a segunda, a terceira, a quarta. E tudo vai ficar em ordem. E é assim que vai ser aqui. Ok? Então, logo abaixo, você vai realmente dizer as pontuações do questionário, abrir e fechar parênteses e um ponto e vírgula no final. Então, eu, o gráfico de pontos das pontuações do questionário, é que ele realmente remove o elemento e a frente da nossa fila simplesmente se livra dele. Isso desaparecerá. Agora, o que vai acontecer é que primeiro criamos uma fila dizendo o tipo de dados Q, R entre o símbolo menor que e maior que e demos um nome a ela. Em seguida, adicionamos elementos apenas dizendo o nome dela dot push, e seja qual for a ordem em que os adicionamos ao pedido, eles estarão em um QR e também será a ordem em que sairão. O primeiro vai primeiro, segundo, segundo, terceiro, terceiro e assim por diante. Em seguida, aqui para imprimi-los. Porque, como eu disse, só podemos ter acesso a essa parte frontal nesta traseira com o método frontal ou com o método. Mas aqui usamos apenas aquele chamado front. E dissemos, uau, pontuações do questionário não estão vazias, o que significa que ainda há algo na nossa fila. Vamos imprimir o que está na frente e depois nos livrar do que está na frente usando o método pop. E você pode reconhecer a palavra pop e a palavra push de quando trabalhamos com vetores no último vídeo, exceto que tivemos que salvar pushback in, pop back. Agora, antes de executarmos nosso código aqui, vamos seguir em frente e inserir uma nova linha aqui. Então, quando um código, e você pode ver, imprimimos 18034 do arquivo. E então, antes de encerrarmos esse vídeo, vou mostrar a vocês um último método. Então, pouco antes de um tempo ao vivo, se dissermos pontuações do questionário , tamanho do ponto, abertura, parêntese de fechamento e ponto e vírgula no final. E vamos continuar e realmente imprimir isso. Então, diga CL logo antes disso, também criaremos um novo depois e executaremos nosso código. Você pode ver que ele imprime o tamanho, assim como poderíamos fazer com o que gostamos de lá. Então, isso é sempre bom. Portanto, temos 1803455 para diferentes elementos aqui com a impressão ou obtenha esse valor com o método de tamanho onde, mas verifique se está vazio com o método vazio. Também aprendemos como verificar a frente do cubo com o método frontal. E também sabemos que podemos voltar para o final da fila com o método back, que é escrito exatamente como você imagina, onde você diz volta em letras minúsculas e configurado com antecedência. E se você está pensando nisso como uma fila em uma loja ou algo parecido, essa será a linha de frente e estará no final da fila. Portanto, essa é uma maneira fácil de lembrar o valor que você está obtendo quando diz frente ou verso. Agora você sabe como criar e trabalhar com a sugestão, como adicionar valores e remover valor. Observamos que é um tipo de contêiner que entra primeiro, primeiro a sair e conhecemos alguns dos métodos associados a ele. E, como acontece com os outros contêineres, existem algumas outras funções que você pode usar com isso que estão associadas a ele. E se você estiver interessado, sinta-se à conferir de qualquer maneira. Mas isso é tudo para este vídeo. Mas antes de passar para o próximo, mas eu quero que você faça é salvar tudo o que você tem, porque vamos usá-lo no próximo vídeo quando falarmos sobre um contêiner muito semelhante. chamado de pilha. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 50. 49: Neste vídeo, falaremos sobre outro tipo de contêiner chamado pilha. Como você pode ver, eu tenho esse código aqui do nosso último vídeo porque, caso vocês tenham perdido, eu queria que vocês salvassem o que tínhamos deles, porque vamos usá-lo novamente neste vídeo. E se você esqueceu, não se preocupe, vá em frente e copie o que eu tenho aqui na tela. Agora, antes de entrarmos nos estoques, precisamos adicionar outro arquivo de cabeçalho. Então, no topo, vamos dizer comida com hashtag. E então, entre o símbolo menor que e maior que, vamos simplesmente dizer isso desse jeito. E mais uma vez, vamos deixar isso para o resto do curso. Portanto, certifique-se de dizer que agora eles estão aqui com o código real. Vamos dar uma olhada nas diferenças entre uma pilha e uma fila. Primeiramente, a única diferença de sintaxe entre uma pilha e uma fila, porque em vez de dizer q, vamos dizer pilha. Quão fácil é isso? Então, vamos dizer pilha. Assim mesmo. Podemos deixar nosso nome aqui se quisermos. Podemos até mesmo deixar esses métodos aqui, se quisermos, porque eles funcionaram exatamente da mesma maneira. E também tem um método push que coloca esses um na frente do outro. No entanto, uma pilha funciona do tipo “último a entrar, primeiro a sair”. Então, se você quiser pensar em empilhar blocos, é colocar uma carta em cima da outra e sempre desenhar do topo. Basicamente, como isso funciona. Então, isso aqui realmente será como nossa carta de baixo, por exemplo, e então teremos a nossa em cima dela, a que está em cima dela e a que está em cima dela. E então, quando tirarmos deles, voltaremos na direção oposta, assim. O último a entrar será o primeiro. Então, este é o topo da nossa pilha. Aqui está o fundo. Portanto, lembre-se de que agora nosso método de tamanho aqui também funciona. Portanto, não precisamos mudar nada lá. Agora, quando chegarmos ao nosso loop while aqui, você notará que esse método assustado tem um erro, tem um erro, porque não temos mais o método chamado front. Em vez disso, dizemos apenas top. Então, o topo da nossa pilha é o que obteremos quando dissermos pop here para você, saindo do topo da nossa pilha, tudo bem, para que todo o resto possa permanecer exatamente o mesmo. Deixe-nos fantasiar. Se você quiser trabalhar com uma pilha ou fila, praticamente nada mudará, exceto com os métodos que vimos aqui, onde a função, você só quer mudar isso em vez do método frontal. que nos deu o primeiro valor colocado em nossa fila, temos esse método principal porque esse é o último valor colocado em nossa fila, porque trabalhamos com um tipo de último a entrar, primeiro a sair arranjo quando se trata de pilhas. Então, se formos em frente e executarmos nosso código aqui, você pode ver que tudo está funcionando. No entanto, imprimimos nossos números na direção oposta à que fizemos com nossa fila, pois é uma pilha e funciona como último a entrar, primeiro a sair, em vez de primeiro a entrar, primeiro a sair. Então, porque 55 estava no topo da nossa pilha e foi a primeira a sair de nossas lanchonetes com 553.480.100. E a razão pela qual temos quatro aqui é porque também imprimimos o tamanho e temos quatro elementos lá dentro. Agora, eu também quero mencionar que o método front não existe, nem o método back. Você não pode obter esse valor mínimo, e é basicamente isso para este vídeo. Agora, assim como acontece com os outros contêineres ou outras funções e nossos métodos disponíveis. E eu recomendo fortemente que você os confira se estiver interessado em usar uma pilha em seu programa. Então, quando você gostaria de usar uma fila e quando você gostaria de usar uma pilha? Então, quando você quiser um contêiner que funcione no estilo de primeiro a entrar, primeiro a sair, use a fila. E quando você quer conter, ele funciona em um estilo de último a entrar, primeiro a sair. Você pode usar a pilha, mas lembre-se que você realmente só tem acesso ao último valor que colocou em uma pilha e em uma fila, você tem acesso a ambos. No entanto, com uma fila, você só pode retirar o primeiro valor que foi colocado com uma pilha é o último valor. Então você tem que ser o último a entrar, o primeiro a sair e o primeiro a entrar, primeiro a sair. Mas se você precisar trabalhar com esses valores médios, lembre-se de que eles provavelmente só vão querer usar um contêiner diferente. E já falamos sobre alguns deles, mas existem outros por aí. Então, se você estiver interessado neles, dê uma olhada. Caso contrário, teremos pelo menos mais um em um vídeo futuro deste curso chamado mapa. Portanto, fique atento a isso. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 51. Capítulo 10 (Loops de presta): introdução a loops de Foreach: Neste vídeo, falaremos sobre um novo tipo de loop. Para cada loop, o que um para cada loop faz é executar uma seção de código para cada elemento em um contêiner de um tipo especificado e criará um desses. E no próximo vídeo, veremos exatamente do que estou falando, mas eu só queria dar a vocês um breve vídeo de introdução o que são e o que fazem. Então, outra coisa a observar sobre um loop foreach é que eles realmente copiam os valores em um contêiner que estão usando para sua operação. E mostrarei um exemplo disso quando trabalharmos neles também. Além disso, para cada loop, percorra apenas um contêiner em ordem. É algo a se observar: ele passará do índice 0 até o final. Agora, deixe-me dar alguns exemplos de quando você pode querer usar um para cada loop. Agora, um exemplo pode ser que você queira imprimir tudo em um contêiner. Assim, você pode imprimir o valor de cada elemento e talvez queira obter o tamanho de uma matriz. Por exemplo, bem, você poderia ter uma variável e, em seguida, no seu a para cada loop, você poderia dizer que para cada elemento em nossa matriz, vamos prosseguir e aumentar essa variável em um. Portanto, você também pode usar um para cada loop para obter o tamanho de um contêiner, apenas como exemplo, qualquer forma, é para este vídeo. No próximo vídeo, vamos criar um loop para cada e trabalhar com ele, bem como compará-lo com bem como compará-lo um loop for-loop, sobre o qual aprendemos no passado. Só para que você possa ver as diferenças e saber quando você gostaria de usar uma em vez da outra. Então, obrigado por assistir e nos vemos na próxima. 52. Capítulo 10 (Loops de (Foreach Loops de Foreach: Neste vídeo, vamos realmente criar um loop de trabalho com para cada loop e compará-los com o loop FOR para que você possa ver a diferença e saber quando usar um em vez do outro. Agora, a razão pela qual eu decidi dividir um loop simples em dois vídeos diferentes, é porque, pessoalmente, achei cada lábio bastante confuso, pelo menos da maneira que eles me explicaram quando eu Eu os aprendi. Então, eu só queria ter certeza de que isso poderia dividi-lo passo a passo e realmente ter certeza de que você entende como e quando usá-los sem problemas. Então, primeiro, vamos começar criando uma matriz de dez números inteiros. Então, vamos dizer que minha matriz está entre colchetes aqui. Vamos colocar dez, assim. E não vamos dar um valor a isso aqui. E então disse que vamos fazer isso em um loop for. Então, aqui embaixo, vamos dizer que para int I é igual a 0, I menor que dez, I mais, mais. Então, dentro do nosso for-loop aqui, vamos dar cada elemento em nossa matriz e valor inicial. Então, vamos dizer minha matriz no índice. I. Lembra que você acabou de colocar isso entre colchetes, assim é igual, certo? Agora, vamos definir isso para cinco. Em seguida, acima ou para loop. Vamos seguir em frente e dizer sram. E se você se lembrar de como usar isso aqui dentro, diremos tempo e, entre parênteses, diremos não. E se você notar quando passamos o mouse sobre S aqui e realmente pegamos um int sem sinal. Então, algumas pessoas gostam de garantir que recebam um int não assinado volta e simplesmente digam não assinado assim entre parênteses. E eles garantirão que você obtenha um valor positivo com esse método de tempo. Então aqui embaixo, em vez de definir tudo igual a cinco, diremos rand entre parênteses assim, seguido pelo operador de módulo. E vamos colocar um 100 mais um. E vamos colocar isso entre parênteses apenas para garantir que a ordem das operações correta ou para defini-la explicitamente. E, abaixo disso, vamos criar um loop, outro for para imprimir nossa variável. Sim, eu sei que poderíamos imprimi-lo aqui, mas você verá por que estamos fazendo isso em um momento. Então, aqui embaixo, vamos dizer que o tempo é igual a 0, eu, menos de dez. Eu mais, mais. E então, entre colchetes, dirá meu índice de matriz I. E, na verdade, diremos C do meu índice de matriz, criarei uma nova linha após cada uma, assim. Agora, abaixo disso, faremos exatamente a mesma coisa que fizemos nesses dois loops. O que vamos fazer em R para cada loop. Mas primeiro, vamos executar nosso programa e garantir que tudo esteja funcionando. Então, como você pode ver, temos dez números aparentemente aleatórios aqui, entre 1100. E agora. Vamos continuar e comentar tudo isso bem rápido. E, na verdade, vamos deixá-lo aqui, então não o exclua. E, abaixo disso, faremos a mesma coisa em um para cada loop. Então, aqui embaixo, vamos criar nosso primeiro loop foreach. E a sintaxe para isso será a seguinte. Portanto, a sintaxe de a, para cada loop tem a seguinte aparência. Vamos dizer quatro. E então, entre parênteses, vamos dizer o tipo de dados de nossos elementos, seguido por um nome de variável e, em seguida, dois pontos. E por último, o nome do nosso contêiner com o qual trabalharemos. Então, aqui teremos nosso contêiner exatamente assim. E caso você não tenha certeza do que eu quis dizer com tudo isso aqui. Você verá em um segundo quando prosseguirmos e criá-lo, e então eu voltarei a analisá-lo. Vou carregar no final para garantir que você entenda. Então, agora vamos criar um que funcione com nossa matriz. Digamos que para em nossa matriz, digite dados como um int. Então esse será o tipo de dados dos nossos elementos lá. Então, aqui, digamos que para int, nosso nome de variável pode ser o que quisermos. Então, vamos colocar algo como ovos. E depois disso, coloque dois pontos seguidos pelo nome do contêiner, que neste caso é minha matriz, assim. E depois disso, eu tenho um conjunto de colchetes encaracolados. E aí está. Agora criamos um para cada loop. Então, como exatamente você lê isso? Bem, eu sei o que liga esses quatro aqui, mas imagine aqui por um minuto. Isso é para cada elemento em nossa matriz, você deseja criar uma variável chamada x e defini-la igual ao elemento. Então, à medida que ele passa por nossa matriz aqui, x será igual a cada elemento à medida que ele percorre. Então, espero que isso faça sentido. Caso contrário, vamos imprimir o resultado do que estou falando aqui. Então, primeiro, temos que prosseguir e inicializar todas as variáveis em nossa matriz. Na verdade, podemos fazer isso com nosso período de loop foreach. Mas primeiro, teremos que dizer algo assim. Vamos dizer que i é igual a 0. E então, toda vez que executamos nosso loop foreach, que será a mesma quantidade de tempo que os elementos em nossa matriz, porque nosso loop foreach é executado uma vez por elemento em nossa matriz. Então, aqui, vamos dizer I plus plus. E também diremos minha matriz entre colchetes aqui. Vamos dizer que i é igual, e vamos seguir em frente e defini-lo igual a I. Então, abaixo disso, criaremos outro para cada loop por meio de nossa matriz. Então, digamos, para uma matriz. E neste bloco de código, basta imprimi-lo. Então diga a linha x e qual é o nosso código. Então, para dar uma visão melhor do que está acontecendo aqui, vamos prosseguir e passar para minha matriz aqui, aqui embaixo, e executar nosso código novamente. Ok, então, como você pode ver, criamos uma matriz, assim como fizemos no passado com dez números inteiros. Em seguida, criamos um iterador aqui apenas criando uma variável chamada I e definindo-a igual a 0. Em seguida, dissemos que para cada número inteiro em nossa matriz, queremos criar uma variável chamada x. Em seguida, dissemos que para cada número inteiro em nossa matriz, queremos executar esse bloco de código. E quando fazemos isso, queremos definir x igual a cada elemento à medida que avançamos. Então, a primeira vez através de x será igual ao elemento 0, depois um, depois 23, etc. Agora, não precisamos nos preocupar com o fato de que isso não foi inicializado porque não fizemos nada com x. Em vez disso, nós Acabei de dizer minha matriz em i, eu tinha 0. Portanto, o índice 0 é igual a I, que na primeira vez é 0. Em seguida, aumentamos em um e passamos por isso dez vezes, dando aos nossos elementos o valor de 0 a nove. Depois disso, criamos outro para cada loop. Dissemos que para cada número inteiro e nossa matriz, vamos percorrer esse bloco de código. Não quero definir x igual a cada um dos elementos à medida que avançamos. Então, como o elemento 0 era 0, x é 0 e, em seguida, imprima 0. Então, da próxima vez, porque o elemento um era um, X0, X1, e depois imprima um e assim por diante até o fim. E isso é exatamente o mesmo que se pegássemos nosso interesse aqui e o movêssemos para o topo. Eu comentei nosso código aqui. E eu vou cortar esse aleatório que eles podem aqui e apenas defini-lo igual a I e no código. E, como você pode ver, imprimimos 0 a nove de nossos quatro loops e imprimimos de 0 a nove mais uma vez com nossos quatro loops de cada um. Então fizemos a mesma coisa aqui e fizemos aqui. Então, quando você gostaria de usar um para cada loop em vez de um loop for of? Bem, pessoalmente, acho que quando estamos inicializando os valores em nossa matriz, isso parece muito mais limpo do que um. Nosso iterador está completamente separado. Então, nossa atualização de variável aqui, sendo I plus plus, também está em uma linha separada. Também não está claro quantos elementos estão em nossa matriz neste bloco de código aqui. Então, pessoalmente, acho que isso parece muito mais limpo para nossa inicialização. Agora, e quando quisemos imprimir tudo em nossa matriz? Bem, isso aqui, nós tivemos que, antes de tudo, saber quantos elementos estão nele. Em seguida, tivemos que criar uma variável para repetir. Em seguida, tivemos que incrementá-lo em um a cada vez. E também tivemos que digitar o nome da nossa matriz mantida por um índice colorido pela nossa variável iteradora. Enquanto aqui dissemos que para cada número inteiro em nossa matriz, vamos definir esse valor igual a cada elemento e bam impresso. Então, pessoalmente, se fosse eu, eu faria alguma coisa. Como eu acho que isso parece muito mais limpo. Agora, nesse caso, você pode fazer o que quiser com que se sinta mais confortável. Mas, pessoalmente, acho que isso parece muito mais limpo e também está muito claro que queremos executar esse loop para o maior número de elementos que estão em nossa matriz versus isso, onde Assad estava lendo isso aqui. Só diz que eu tenho menos de dez anos. E então podemos supor que essas quantas variáveis temos em nossa matriz. É muito claro que vamos executar isso para tantos elementos quanto houver em nossa matriz. E isso ainda ficaria claro se isso aqui era uma fila, uma pilha ou um vetor, etc. Agora, vamos seguir em frente e fazer mais uma coisa com isso aqui. Então, vamos colocar de volta em nossa declaração aleatória aqui. Então, diremos que é igual ao módulo rand a 100 mais um. Então, aqui embaixo, vamos criar uma variável que diremos ser o valor mais alto. Então, podemos dizer o maior número. Então, isso é igual a 0. Então, dentro do nosso loop foreach, podemos simplesmente dizer algo assim. X é menor que o número mais alto. Em seguida, queremos definir o maior número igual. Assim mesmo. Eu lembro que isso não precisa ser x. Podemos chamá-lo do que quisermos. Então, por exemplo, se eu quisesse deixar isso claro, eles poderiam dizer renomear elemento, certo? Portanto, se o elemento atual em nossa matriz for menor que o número mais alto, número mais alto será igual ao elemento atual. E agora, aqui embaixo, logo após nosso loop foreach, podemos simplesmente dizer algo como o maior número. E então, antes disso, vamos colocar algum texto. Digamos que o espaço numérico. Vamos adicionar outro operador de inserção ali mesmo. E quando eu codifico e o, e o motivo que imprimiu 0, porque isso realmente precisa dizer se o elemento atual é maior que o maior número que queremos definir, maior número é igual a o elemento atual. E lá vamos nós. Nosso maior número foi talvez seis. Então, dissemos o maior número de 96. Portanto, há apenas outro caso de uso para a, para cada loop. Agora, usaremos novamente para cada loop neste curso. Então, se você não entender completamente , não se preocupe com isso. Como eu disse, nós os usaremos novamente no futuro. E vamos recapitular rapidamente uma adequada. E basicamente como interpretar essa linha aqui. Então você vai dizer que para todas as letras minúsculas e depois m parênteses, eu tenho o tipo de dados dos elementos da matriz. Então, temos uma matriz int, então dissemos int, então você criará um nome de variável, e isso pode ser o que você quiser. Então, acabamos de dizer elemento atual, então você vai ter dois pontos. E, finalmente, o nome do contêiner, seguido por parênteses fechados e colchetes. Me desculpe. Basicamente, dizendo que para cada elemento em nossa matriz, vamos criar essa variável. E essa variável será definida como igual a cada um dos valores em nossa matriz à medida que for avançando. E vai começar no índice 0 e ir até o fim. Agora, no último vídeo, se você se lembra, eu disse que através do loop for each realmente copia a matriz para sua operação. Agora, o que eu quis dizer com isso? Bem, deixe-me te mostrar. Então, se eu continuar e remover esse código aqui por um momento, se disséssemos algo como elemento atual é igual a dez, e então aqui em cima criar um iterador. Então, se você disse que eu é igual a 0, e aqui embaixo diremos I mais, mais. Em seguida, imprima sua matriz no índice i de cada vez. Então, vamos criar uma nova linha depois. E então vamos apagar essa linha aqui embaixo e executar nosso código. Você pode ver que tudo em nossa matriz não mudou. E isso porque esse elemento atual aqui é apenas a cópia dos valores em nossa matriz. E se imprimirmos o elemento atual aqui, em vez disso, você pode ver que podemos defini-lo como dez e imprimi-lo. Mas quando a tivemos, como ele se saiu há apenas um minuto. Se executarmos nosso código aqui, você pode ver que ele não imprime dez para cada um deles. E isso porque o elemento atual aqui é apenas uma variável à qual queremos que seja igual. Cada elemento em nossa matriz. À medida que passei, na primeira vez, era igual ao meu índice de matriz 0, depois ao meu índice de matriz um. Mas alterar o elemento atual não altera, na verdade, o valor em nossa matriz. Portanto, essa variável aqui é apenas uma cópia de cada um dos elementos inteiros em nossa matriz e não tem realmente nenhum efeito sobre os elementos em nossa matriz. Então aí está. Espero que isso tenha feito sentido. Caso contrário, trabalharemos mais com cada loop durante todo o curso. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 53. 52: Neste vídeo, falaremos sobre a palavra-chave automática. Então, basicamente, a palavra-chave auto é essencialmente apenas um espaço reservado para um tipo, mas não é um tipo em si, o que significa que você não pode converter um tipo de dados diferente para ela. Agora, se você estiver usando a palavra-chave auto, a variável deverá ser inicializada. E eu vou te mostrar o que quero dizer com isso aqui. Então, se eu estivesse criando uma variável aqui embaixo e em vez de inserir o tipo de dados diretamente, eu simplesmente sentei sobre eles. E então, assim, eu receberia um erro porque as variáveis automáticas precisam ser inicializadas. Agora, deixe-me examinar rapidamente algumas coisas úteis sobre o uso da palavra-chave auto. Em seguida, veremos alguns exemplos e veremos onde e quando isso pode ser útil. Agora, pessoalmente, não sou um grande usuário. A palavra-chave automática. E se você estiver vindo de outra linguagem de programação, diga algo como C-Sharp, por exemplo e é basicamente algo como ter a palavra-chave var ou algo parecido. Agora, uma razão pela qual você pode querer usar a palavra-chave auto é por causa de sua robustez. Se o tipo da expressão foi alterado, isso inclui quando um tipo de retorno de função foi alterado, ele ainda funcionará. E eu sei que não falamos muito sobre funções, mesmo que costumássemos ter algumas delas. Mas você verá o que queremos dizer com isso em um próximo vídeo. Depois, há o desempenho. E o que quero dizer com isso é que você tem a garantia de que não haverá conversão e obterá o tipo certo de que precisa. E eu vou te mostrar isso aqui em um minuto. Em seguida, temos a usabilidade. E isso acontece porque você não precisa se preocupar com o nome do tipo, dificuldades de ortografia e erros de digitação. Então, se você entrar em nomes de tipos mais longos, e na verdade abordaremos um deles no próximo vídeo, quando falarmos sobre mapas, o bom da palavra-chave auto é que ela é muito mais curta e você está menos propenso a erros. Em seguida, há a eficiência de simplesmente digitar isso porque é uma palavra tão curta você está cortando pode ser mais eficiente nesse sentido. Agora, vamos dar uma olhada em como usar a palavra-chave auto. E, como eu disse, é essencialmente apenas um espaço reservado para um tipo, embora não seja um tipo em si. E como funciona é que, quando você escreve automaticamente, nosso programa aqui descobrirá automaticamente o tipo que precisamos. Então, vamos dar uma olhada nisso criando algumas variáveis diferentes. Então, se eu quisesse criar um número inteiro, eu poderia dizer que o número automático é igual a cinco. E se eu passar o mouse sobre isso, você pode ver que eu criei uma variável inteira. E se transformarmos isso em um carro alegórico como esse, você pode ver que agora é um carro alegórico. E se o transformarmos em algo assim, você pode ver que ele automaticamente se transforma em um duplo. Então, como eu disse, você pode basicamente usar essa palavra-chave para que ela descubra automaticamente o tipo que você precisa. Deixe-me ir em frente e mudar isso de volta para uma tinta rapidamente. E, na verdade, vamos ligar para isso diretamente. E aqui embaixo, vamos dizer algo como número automático, café é igual a número, sem mais nem menos. E agora isso copiará automaticamente esse valor para aqui, assim como vimos no passado. E você pode ver que essas são automaticamente uma variável inteira. E esse é um exemplo pequeno e muito simples de quando isso pode ser útil. Porque agora, se mudássemos o tipo de dados do número para dizer um flutuador e fizéssemos algo assim. Você pode ver que isso se torna automaticamente um flutuador. Nem precisávamos mexer com nosso código aqui embaixo. E também, digamos que quiséssemos ter algum código para imprimir uma matriz, que fizemos no passado. Então, deixe-me ir em frente e remover isso rapidamente. Aqui, diremos int minha matriz. E então os colchetes dirão algo como cinco. Assim, para criar uma matriz inteira de cinco variáveis. Então, vamos realmente seguir em frente e ir para cada um desses valores de K. Então, digamos algo assim. Tudo bem, então agora todos os cinco têm um valor inicial. E lembre-se, se você quiser, você pode simplesmente remover desse número aqui, não, descobrir automaticamente que queremos cinco valores na lista. E aqui embaixo, podemos imprimir tudo em nossa matriz usando um para cada loop, que funcionará automaticamente independentemente de quantos itens estejam em nossa matriz. Poderíamos dizer algo como quatro x dois pontos na minha matriz. Então poderíamos simplesmente dizer C fora X na linha. E depois de executar o código, como sabemos do passado, isso vai imprimir tudo em arte, certo? Agora, mesmo que aqui em um código tão pequeno, é muito óbvio que estamos trabalhando com uma matriz inteira. Algo que poderíamos fazer é apenas dizer automático, e agora nem precisamos nos preocupar com isso. Isso saberá automaticamente qual tipo de dados está em nossa matriz. Não precisamos pensar nisso. Se tivéssemos um código maior aqui, não precisaríamos voltar e verificar que tipo de dados estamos usando. Nós já sabemos disso aqui. Queremos colocar o tipo de dados do nosso contêiner. De qualquer forma, muitas vezes dizer automático será mais fácil, especialmente se estivermos trabalhando com um tipo de dados mais complicado, que você verá no próximo vídeo. Ao fazer algo assim, esse é provavelmente um dos meus casos de uso mais favoritos para essa palavra-chave. Eu posso simplesmente dizer automático, não preciso pensar nisso. Eu sei que quero o tipo de dados disso de qualquer maneira. E se você se lembrar daqui de cima, sabemos que não haverá nenhum tipo de conversão. Ele só vai obter o tipo exato de dados que precisamos. E isso é o que queríamos colocar aqui de qualquer maneira. E também, digamos que, no futuro, dependendo da nossa matriz aqui servia, pensamos: “Quer saber, não vou mais poder usar números inteiros para o que estou fazendo”. Eu preciso usar carros alegóricos. Bem, poderíamos simplesmente alterá-los para tornar tudo isso um valor flutuante como esse. E você pode colocar qualquer número que não estivesse aqui, sem realmente fazer nenhuma diferença. E ei, olha isso. Eu nem preciso mexer com meu código aqui embaixo. Então, isso é fantástico. Dito isso, existem algumas deficiências no uso automático, e eu só quero informá-lo sobre elas também. Além disso, como eu disse, eu não uso muito automóveis pessoalmente, mas sei que há muitas pessoas que usam. E muitas vezes, se você estiver lendo o código de outra pessoa, há uma boa chance de que essa pessoa use a palavra-chave auto. E eu até vi algumas pessoas simplesmente usarem o automático e nem mesmo digitarem lá, digitam nada. Esses, basta dizer automático e usá-lo para praticamente tudo. Agora, pessoalmente, digamos que estamos criando uma variável como essa e x é igual a cinco. Agora, eu sei que isso é um número inteiro. Eu posso dizer isso. Eu sou um olhar muito rápido. Eu nem preciso pensar nisso, mas se eu digitar fora daqui, bem, sim, provavelmente posso deduzir que isso é um número inteiro verificando o número da pesquisa aqui. Ou se eu tivesse algo assim em que dizemos auto O é igual a x, bem, eu nem sei o que é b, a menos que eu passe aqui e passe o mouse sobre isso só para descobrir que isso é um número inteiro porque aqui também é um número inteiro. E eu sei que no começo eu disse, bem, ei, se mudássemos isso de um int para um flutuador, então não precisamos mudar essa haste aqui. No entanto, e se tivéssemos um método que exigisse o tipo original? Agora, teremos que examinar quais métodos foram todos confusos com isso. E tenha em mente qual é o novo tipo de dados, etc. E pode ficar bem confuso. Então, pessoalmente, prefiro ver o tipo na maioria dos casos, mas fique à vontade para experimentar mesmo e ver o que você prefere fazer. No entanto, como eu disse, para casos como esse, especialmente quando trabalho com tipos de dados mais complicados onde eu sei que só quero que o tipo de dados exato do meu contêiner esteja aqui. Bem, eu poderia muito bem dizer automático, é muito mais fácil. Eu realmente não preciso pensar nisso. E se por algum motivo meu tipo de matriz mudou aqui, e eu estou apenas imprimindo esses valores de qualquer maneira porque não tenho nenhum método específico aqui. Bem, eu posso apenas dizer automático. Não preciso pensar nisso. Não preciso me preocupar em mudar isso mais tarde. Isso vai funcionar de qualquer maneira. Isso é tudo para este vídeo. Eu só queria que você soubesse qual a palavra-chave automática e o que é essa bifurcação? Porque eu sei que, se você entrar na programação, verá a palavra-chave auto. Se você vem de outra linguagem de programação, há uma boa chance de você ter visto a palavra-chave var e estamos nos perguntando se o C Plus Plus tinha algo semelhante. Então aí está. Então, espero que você tenha uma boa compreensão de como usar a palavra-chave auto e para que ela serve, basicamente, basta colocá-la em nosso programa aqui para descobrir de que tipo de dados precisamos sozinhos. E você não quer ter que dizer isso explicitamente. Mas se você quiser que seu tipo de dados seja escrito explicitamente, bem, então você mesmo precisará colocá-lo lá. Enfim. Obrigado por assistir, e nos vemos na próxima. 54. 53: Neste vídeo, falaremos sobre outro contêiner chamado mapas. Agora, mapas e C plus plus são um tipo de contêiner que armazena elementos forma não mapeada, onde você tem uma chave e um valor mapeado. Agora, o valor da chave geralmente é usado para classificar e identificar de forma exclusiva os elementos em seu contêiner, enquanto o valor mapeado armazena o conteúdo associado a essa chave. Agora, em vez de confundir você com um monte de mapas, vamos criar um nós mesmos. E antes de fazermos isso, você vai querer ir em frente e adicionar esse arquivo de cabeçalho sendo apenas um mapa. Então, vamos seguir em frente e começar. Agora, a sintaxe de um mapa é a seguinte. Primeiro, você dirá mapa, tudo em letras minúsculas, o símbolo menor que, seguido por um tipo de dados que será para sua chave. Então, assim, você terá uma vírgula seguida pelo tipo de dados do seu mapa. Então, quando o símbolo maior que, e depois disso, você terá o nome do mapa seguido por um ponto e vírgula. Então, como você pode ver, é muito parecido com criar um vetor, uma fila ou uma pilha. No entanto, em vez de ter apenas um tipo de dados, agora precisamos lembrar que seu tipo de dados chave geralmente é classificar e identificar de forma exclusiva qualquer que seja o tipo de dados mapeado nesses tipos de dados. diferente, aliás. Então você não precisa armazená-lo, apenas termina. Você pode armazená-lo em uma string ou, essencialmente, o que quiser lá. Então, vamos seguir em frente e criar um mapa. E vamos seguir em frente e basear isso na lista telefônica do nosso caso, só porque todo mundo sabe o que é uma lista telefônica. Então, espero que seja mais fácil entender dessa forma. Então aqui embaixo, vamos dizer mapa e depois o símbolo menor que. E então vamos identificar de forma exclusiva cada um na lista telefônica pelo nome. Então, vamos seguir em frente e dizer string, exatamente como aquela vírgula. E então o número de todos será armazenado como um número inteiro. Então, diremos int. Vamos ligar para essa lista telefônica. Assim mesmo. Então, aqui temos nosso mapa vazio. E então, aqui embaixo, adicionaremos alguns elementos ao nosso mapa. Tudo bem, então vamos adicionar alguns elementos ao nosso mapa. E para fazer isso, vamos apenas dizer o nome do nosso mapa da lista telefônica. Em seguida, usaremos o modificador de acesso de membros. Então, vamos dizer ponto aí, a propósito, insira todas as letras minúsculas. E então, entre parênteses, vamos colocar o tipo agora porque nosso mapa contém dois tipos de dados diferentes como ele, que estão conectados. Na verdade, isso é chamado de pagador. Portanto, um pai e C plus plus são essencialmente apenas um contêiner que armazena dois valores. E esses valores podem ou não ser do mesmo tipo de dados, aqui, vamos dizer inserção de pontos na agenda telefônica. E depois disso, vamos dizer cabelo, tudo em minúsculas aqui. E então um símbolo menor que seguido pelos mesmos tipos de dados do nosso mapa. Então, se você quiser, você pode simplesmente copiá-los e colá-los. Mas vamos descontar isso, apenas tentando praticar aqui, sem mais nem menos. E então, entre parênteses, precisamos colocar os valores que queremos inserir na string e na string. Vamos colocar um nome aqui, algo como a vírgula Jack e, em seguida, o valor inteiro. E podemos simplesmente inserir qualquer número de dez dígitos que queiramos representar seu número de telefone. Em seguida, colocaremos um ponto e vírgula no final e vamos adicionar mais alguns números. E em vez de digitar tudo isso de novo, vou copiar e colar isso algumas vezes. Em seguida, examinaremos cada um desses oito nomes de chave diferentes. E você vai querer que esse primeiro valor aqui seja exclusivo para todos. Então você não gostaria de colocar o nome de Jack e vários alelos. E se você está realmente fazendo uma lista telefônica, gostaria de ter um sobrenome, por exemplo, mas como estamos apenas trabalhando com algo pequeno como aqui, todos entendem. Então, diremos Jack, John, Pam e algo parecido. E darei a cada um desses oito números diferentes. E fique à vontade para adicionar os números que quiser , em vez de ter que copiar o que tenho aqui exatamente, pois não fará nenhuma diferença para o nosso exemplo. Agora, e se quisermos ir em frente e imprimir o mapa? Bem, poderíamos fazer isso usando um para cada loop. Então, se vamos dizer e então podemos dizer par, seguido pelo símbolo menor que e depois tensão. E o símbolo maior que. E depois disso, diremos pessoa, espaço, espaço do cólon, nome do nosso mapa, havia uma lista telefônica e, em seguida, um colchete encaracolado aberto e fechado, assim. E então podemos imprimir cada um, e eu vou te mostrar como fazemos isso. Então, vamos dizer CO, seguido por pessoa, porque essa é a variável que estamos usando para acessar cada uma delas. Vamos dizer dieta. E então observe que surge um primeiro e um segundo. O primeiro como esse primeiro valor sendo nossa string, então esse será o nome deles. E então o segundo seria o valor inteiro ou, nesse caso, o número de todos. Então, vamos dizer pessoa ponto primeiro, e depois disso, vamos colocar em um espaço como esse. E então vamos dizer pessoa naquele segundo, seguida pela linha N, exatamente assim. E se executarmos nosso código aqui, você pode ver que todos os nossos números estão realmente confusos. Agora, por que isso? Bem, como mencionei antes, um número inteiro só pode conter um determinado intervalo e, eventualmente, envolvê-lo e seguir em frente. Falamos sobre isso em um vídeo anterior lá. Então, como podemos corrigir isso? Bem, esse é um ótimo exemplo de quando você vai querer procurar um tipo de dados diferente para atender às suas necessidades e os erros que podem surgir se seu tipo de dados for muito curto para ele, o valor que você é tentando manter, nesse caso aqui, meu maior valor que eu estou tentando manter seus mais de 8 bilhões. E se eu passar o mouse sobre ele, você pode ver que ele assume que esse valor é um pulmão. Pulmão. E como não vamos dar ninguém um valor negativo para o número de telefone, podemos muito bem tornar essa variável sem sinal. Então, para corrigir isso aqui, vamos dizer sem assinatura, longo, longo, exatamente assim. E vamos copiar e colar isso para cada um deles. Assim, certifique-se de copiar isso para cada elemento que adicionamos, bem como um R para cada loop. Então, agora criamos um mapa a sequência de caracteres do dia inteiro e um longo, longo sem sinal , que pode conter um número inteiro positivo muito grande. E chamamos esse mapa de lista telefônica. Em seguida, inserimos vários elementos dizendo o nome do nosso mapa seguido por esse método de inserção. E então nosso tipo de dados aqui era um par que, como eu disse, são dois tipos de valores diferentes, ou pode conter dois tipos de valores diferentes. Devo dizer que, como poderíamos ter inventado os dois, uma string ou um int ou o que quisermos que esteja lá. Mas, nesse caso, definimos uma corda e uma longa, longa e não assinada para representar uma lista telefônica. Então, aqui embaixo, acabamos de criar um loop simples para cada par de uma corda e não assinado longo, longo em nossa lista telefônica ou um contêiner aqui está um mapa. Nesse caso, queremos criar uma variável chamada pessoa e defini-la como igual a cada elemento à medida que avançamos. Então, podemos imprimir primeiro o ponto da pessoa, que será nosso primeiro valor aqui e nosso par, depois colocamos um espaço e depois também imprimimos a segunda pessoa, que é nosso segundo valor aqui, seguido pela criação de uma nova linha. E se executarmos nosso código novamente, você pode ver que isso agora funciona muito bem. E nossos números são o que digitamos aqui porque um longo, longo sem sinal é capaz de conter um valor tão grande. Agora, observe como esse tipo de dados ocupa muito espaço e, francamente, parece um pouco feio. Bem, há uma maneira fácil de corrigir isso usando a palavra-chave automática sobre a qual acabamos de falar no último vídeo. Podemos simplesmente dizer automático, e agora não precisamos colocar todas essas coisas extras. E se executarmos nosso código, você pode ver que ele funciona perfeitamente sem problemas. Como palavra-chave automática, descobri automaticamente o tipo de dados exato que precisávamos. Então, quão bom é isso? E parece muito mais limpo do que isso, na minha opinião. No entanto, você pode fazer isso de qualquer maneira. No entanto, só para mostrar uma coisa, não podemos colocar o automóvel aqui, pois isso não funcionará. Então, aqui está um exemplo de quando você não pode usar a palavra-chave auto. Em vez disso, precisamos colocar o valor diretamente. Então aí está. Há uma maneira básica de criar um mapa, adicionar elementos e usar um para cada loop com um mapa para imprimir os valores dentro dele. Agora, antes de encerrarmos este vídeo, vou mostrar alguns métodos extras, mas você pode usar com seu contêiner de mapas. Mas, como sempre, há muito mais. Portanto, sinta-se à vontade para procurá-los se decidir usar um mapa em um de seus programas. Então, o primeiro que veremos é como remover um elemento do nosso mapa. Mas antes de fazermos isso, vou adicionar um comentário extra aqui. Crie o mapa. E então, aqui, vamos remover a coluna de valor. Então, bem rápido, se você se lembra no início do vídeo, eu disse que um mapa está organizado como um mapa real. Teremos valores-chave e, em seguida, os valores mapeados nesta chave aqui não são apenas para classificar os elementos em seu contêiner, mas também para localizar elementos dentro de seu contêiner. Então, aqui embaixo, se quisermos remover um elemento em nosso contêiner, simplesmente precisamos conhecer a chave do elemento. E deixe-me seguir em frente e mostrar como isso é feito. Então, aqui, vamos dizer que a lista telefônica o nome do nosso mapa, apagar pontos. E então, entre parênteses, vamos simplesmente colocar o valor chave do elemento que queremos remover. Então, digamos que John, por qualquer motivo, se mudado da cidade e não precisemos mais do número dele em nossa lista telefônica. Bem, podemos simplesmente colocar John entre aspas porque estamos trabalhando com uma string e colocar um ponto e vírgula no final. Agora, quando executarmos nosso código, John não fará mais parte da nossa lista telefônica. Então, é assim que você remove elementos de um. E deixe-me seguir em frente e mostrar algo mais sobre esse método também. Então, se prosseguirmos e copiarmos esta linha aqui onde inserimos John e/ou lista telefônica e colamos assim e damos a esta uma cor diferente. Assim. E execute nosso código. Você pode notar que nenhum John existe, e isso porque isso realmente removerá todos os elementos com essa chave. Há outro exemplo de por que você deseja garantir que cada elemento em seu contêiner de mapa tenha um valor de chave diferente. Agora, vamos dar uma olhada em um último método que podemos usar com mapas aqui. Agora, este é apenas o último que vou mostrar a você lembre-se de que existem muitos outros por aí, se você estiver interessado. Então, com isso, vamos permitir que imprimissemos o número de telefone da pessoa que estamos procurando. Outro ótimo exemplo de por que você quer dar a todos uma chave específica. E, na verdade, vou remover esse John extra que adicionamos à nossa lista telefônica aqui. Então, aqui embaixo, vamos dizer elemento baseado em. Então, abaixo, tudo o que precisamos fazer como lista telefônica do CEO. E então, entre parênteses, coloque seu valor chave entre aspas aqui, porque estamos trabalhando com cadeias de caracteres para nosso valor-chave, posso dizer, Ei, vamos pegar o número de Tams, assim mesmo. E imprimiremos o número da Pam. E, na verdade, vou comentar nosso loop de foreach para que não ocupe nosso loop de foreach para que não espaço quando executamos nosso programa. E se eu executar nosso código, ei, lá vamos nós. Tem o número dos cafetões ali mesmo. Então aí está. Espero que agora você tenha uma compreensão básica de como os contêineres de mapas funcionam no C plus plus e tenha uma compreensão básica de suas funcionalidades. Você deve querer usá-lo em um programa futuro seu? De qualquer forma, espero que tenham gostado do vídeo. Obrigado por assistir, e nos vemos na próxima. 55. Capítulo 10 (Loops de (Foreach Iteradores: Neste vídeo, apresentarei uma introdução muito básica ou muito breve aos iteradores. E, honestamente, eu nem ia jogar isso no curso C plus plus para iniciantes, mas vejo isso com tanta frequência que decidi que vou jogar lá. Então, pelo menos vocês sabem o que é quando se deparam com isso. No entanto, o exemplo que vou dar não é realmente o melhor caso de uso para isso. Mas, como eu disse, eu vejo isso o tempo todo. Então, eu só quero ter certeza de que vocês não fiquem completamente desprevenidos quando virem isso muito cedo, quando começarem a criar seus próprios programas e a analisar código de outras pessoas como referência. Então, vamos começar. Então, primeiro, o que é um iterador? Um iterador é um objeto usado para iterar sobre elementos em um contêiner. De qualquer forma, existe a ideia básica do que é um iterador. É como eu disse, é apenas um uso adjetivo para iterar sobre elementos em um contêiner, o que é algo que fizemos no passado. Mas agora vou mostrar como fazer isso usando um objeto iterador real. E também mostrarei como podemos fazer a mesma coisa usando a para cada loop, como fizemos no passado, só para que você possa ver as comparações entre eles. E, como eu disse, esse realmente não é o melhor caso de uso para isso. E normalmente eu usaria apenas um loop para cada. E você verá o que quero dizer aqui em um momento. Então, primeiro, vamos criar um vetor. Vou digitar assim. E então vamos chamar esses números e defini-los como iguais aos seguintes. Então, entre colchetes aqui, vá em frente e insira qualquer visualização de cinco números. Só vou dizer 12345 por uma questão de simplicidade. E, na verdade, analisamos como repetir isso com alguns métodos diferentes. Então, se você se lembra, fizemos isso com um loop for e fizemos isso com um para cada loop. Agora, fazer isso com um para cada loop, se você se lembrar, era simplesmente dizer algo como número de porta, números de dois pontos como esse. E então, um bloco de código de digitação era um número impresso como esse. E isso vai funcionar muito bem. Isso imprimirá tudo em nosso vetor de números. Mas como podemos fazer isso com um iterador? Bem, primeiro, vamos declarar um iterador. E para fazer isso, vamos redigitar o tipo de contêiner, que é um vetor do tipo int seguido por dois pontos. E então vamos dizer iterator em letras minúsculas assim. E depois disso, precisamos de um nome e uma convenção de nomenclatura comum. nome muito comum, se você limpar ou usar um iterador, será simplesmente TI. E isso por si só é uma declaração para nosso iterador. Então, vou descobrir isso e chamar essa declaração iteradora para nossos números assim. E eu só estou fazendo isso como referência. Então vocês não precisam copiar essa parte se não quiserem. E deixe-me ampliar aqui para vocês. Mas logo abaixo disso, emigre e inicialize para ele. Então, inicialização iterada, assim. Podemos declarar e inicializá-lo na mesma linha. Então, digamos, inicialização do iterador em declaração para nosso vetor de números. E o que faríamos para fazer isso é dizer tipo de contêiner, seguido pelos dois iteradores do Colin than, o nome mais uma vez. E então continuaríamos com o ponto em que queremos que nosso iterador comece. Essencialmente, a forma como faríamos isso nesse caso é dizer o nome. Somos contêineres sendo números, morremos. Novamente. Agora, essa é a sintaxe básica para declarar e inicializar um iterador. Sintaxe do iterador. Lembre-se de que a sintaxe é basicamente apenas a regra para algo, essencialmente será o contêiner. E então você vai ter que fazer isso, Colin é assim. Eu vou dizer iterador, seguido pelo nome do iterador. Eu só vou escolher aqui. E então, se você quiser inicializá-lo, você dirá igual a seguido pelo nome real do contêiner dot. E então, se você quiser defini-lo como o primeiro valor, pelo menos você poderia dizer que começou. No entanto, existem outros métodos, então você não precisa iniciá-lo logo no primeiro elemento do contêiner. De qualquer forma, vou comentar isso também. E vamos começar com a declaração. Então, aqui embaixo, vamos dizer vetor no iterador de Colin, TI, e precisaremos colocar um ponto e vírgula no final. Tudo bem, então vamos lá. Declaramos nosso iterador. Agora, vamos seguir em frente e criar um for-loop. Thrill, nosso vetor aqui em cima. E, na verdade, vou copiar esse código e movê-lo para cá para que possamos manter a tela aqui para vocês. E eu vou remover esse daqui de cima. E eu poderia comentar isso apenas para que não apareça realmente no console de lá. E criaremos um loop for para trabalhar com nosso vetor. Então, vamos dizer quatro. E então, dentro daqui, vamos simplesmente inicializar nosso iterador que já criamos. Eu vou dizer que a dieta de TI é igual a números. Novamente. Como eu disse, isso vai definir nosso iterador para o valor inicial do vetor R sendo um. E depois disso, para uma condição, diremos essencialmente enquanto TI, então comece abordando a TI aqui. Ser nosso iterador não é igual a. Números e muito rápido e iterador, na verdade, apenas apontam para a localização na memória dos elementos em nosso contêiner, o que pode ser meio confuso. E abordaremos isso um pouco mais quando falarmos sobre dicas no futuro. Mas, por enquanto, saiba que basicamente aponta que a localização na memória não é a mesma coisa que nosso elemento real. Ok? Então, basicamente, estamos dizendo queremos criar um iterador que comece com o primeiro valor aqui. E então, enquanto nosso iterador não é igual ao último elemento ou não está apontando para o último elemento. Eu poderia dizer que queremos executar nosso código. Agora, depois disso, podemos simplesmente dizer IT plus, mais o nome de um gerador plus, plus. E isso vai funcionar muito bem. Agora, esse fim de método aqui não é realmente o último valor em nosso contêiner. Na verdade, é essencialmente o valor depois disso, se existisse, como poderíamos ver. Então, basicamente, o que não estamos apontando para um valor que não existe. Então, vai começar desta vez. Vamos lá, 2345. E então, uma vez apontando para o sexto elemento imaginário, então seria igual a esse fim. Bem, não é igual a isso. Queremos continuar executando nosso código. Então, espero que isso faça sentido. Basicamente, se não houvesse um sexto elemento imaginário aqui, é a isso que isso aqui está se referindo. Então, o que estamos apontando, tudo o que está em nosso contêiner e queremos fazer o seguinte e repeti-lo. Em seguida, teremos colchetes encaracolados abertos e fechados. E então, dentro daqui, vamos simplesmente imprimir, agora eu crio um novo. Agora, observe que recebemos esse erro e isso porque, na verdade, precisamos colocar um símbolo de asterisco antes de dizê-lo aqui. Agora, por que temos esse asterisco? E, na verdade, abordaremos isso um pouco mais quando falarmos sobre dicas. Mas, essencialmente, lembre-se de como eu disse que um iterador está apontando para o local na memória onde esse elemento está. Bem, esse asterisco nos permite desreferenciar esse ponteiro. Então, em vez de nos devolver a localização e a memória, recuperaremos o valor real. Então, espero que isso tenha feito sentido. Caso contrário, falaremos sobre mais informações quando tivermos dicas mais adiante no curso. Mas saiba, por enquanto, colocamos isso aqui para obter o valor real e não o endereço de localização da memória. Então, se executarmos nosso código aqui e, como você pode ver, imprimiremos 12345 em linhas separadas. E se você está se perguntando como aumentei o zoom no console ou no Visual Studio aqui, você pode realmente segurar a tecla Control e usar a roda de rolagem para ampliar e diminuir o zoom. No entanto, na janela do console aqui, na verdade, apenas aumenta e diminui o tamanho da janela como um todo, o que eu acho que retoma que você está de uma forma indireta. Mas, de qualquer forma, imprimimos 12345 em linhas separadas. Agora, como eu disse, no caso específico, eu pessoalmente nunca faria isso. E muitas vezes você até o verá escrito onde a declaração e a inicialização estão na mesma linha. Então, se copiarmos e colarmos isso aqui embaixo, não queremos colocar o nome duas vezes. Então, faça isso e remova-os aqui. Isso vai funcionar muito bem. E muitas vezes é assim que você verá isso feito, como acontece com a declaração do iterador e a inicialização dele na mesma linha exata. Então é assim que eu vou seguir em frente e agora, como eu disse, neste caso, você provavelmente nunca gostaria de fazer isso porque isso para cada loop que temos aqui, funciona muito melhor. Parece muito mais limpo. Mas, como mencionei no início do vídeo, eu vejo isso o tempo todo. Então, eu só queria ter certeza vocês sabem o que está acontecendo aqui. Então, basicamente, em nosso loop for, estamos criando um iterador colocando o tipo de contêiner aqui, seguido por dois pontos, e depois a palavra-chave iterator, depois o nome do iterador, que você frequentemente verá como TI. Mas você pode colocar o que quiser seguido pelo operador de atribuição para inicializá-lo. Em seguida, inserimos o nome real do contêiner e damos a ele um ponto de partida. Porque, como eu disse, um iterador aponta para o local na memória em que um elemento está em um contêiner. Então, estamos basicamente dizendo: Ei, comece com o primeiro elemento. Então dissemos, embora nosso iterador essencialmente não esteja apontando para o elemento após o último. Então esse é o nosso último elemento. Se estivesse apontando para um elemento imaginário de seis, é a isso que esse número é comprado e seria igual. Bem, não estamos apontando para isso. Queremos seguir em frente e aumentar a iteração em um, o que nos levará adiante em nossos elementos aqui. Em seguida, queremos imprimir o valor real qual nosso iterador está apontando e em uma nova linha a cada vez. E trabalhamos com quatro loops, e assim por diante. Portanto, você deve entender o básico. Basicamente, podemos declarar e inicializar uma variável aqui. Temos uma condição aqui e, em seguida, nossa atualização de variável, que é onde atualizamos nosso iterador nesse caso. Agora, embora esse exemplo não seja ótimo e seja um uso muito básico de um iterador, há muitos outros métodos que você pode usar com ele para fazer coisas diferentes. Existem casos de uso reais em que você gostaria de usar um iterador. E isso ocorre porque nem todo contêiner salva seus dados de maneira contínua, onde tudo está em ordem e você pode usar apenas um loop básico de quatro. E, às vezes, um iterador pode ser necessário. Se você estiver trabalhando com um tipo diferente de contêiner que não o armazena em valores em uma ordem sequencial, como faz um vetor ou uma matriz. Um iterador pode ser algo que você precisará usar e analisar um pouco mais. Mas essa é uma visão geral básica de uma, bem como um exemplo básico de como criar e usar uma como exemplo, que você poderá ver com bastante frequência se começar a examinar o código de outras pessoas, especialmente de qualquer maneira, é basicamente isso para este vídeo. Eu só quero ter certeza de que você sabia o que era um iterador e tinha uma compreensão básica de como seria usar um, para que você não fique completamente desprevenido quando surgir. De qualquer forma, obrigado por assistir. Espero que tenham gostado do vídeo e, como sempre, nos vemos no próximo. 56. Capítulo 11 (Enums): Introdução a encadernações: Neste vídeo, falaremos sobre enums. E eu vou dar a vocês uma breve introdução neste vídeo. E então, nos próximos três vídeos, vamos realmente criar e trabalhar com eles. Agora, normalmente, ao aprender uma linguagem de programação, você aprenderá bem cedo. No entanto, decidi adiá-los até este ponto porque, por não achei realmente necessário expulsar vocês muito cedo no curso. E eu os achei meio confusos quando eu estava aprendendo programação pela primeira vez. Então, pensei em deixar vocês entenderem o idioma básico antes de colocá-los lá. Mas você os verá com muita frequência. Eles são úteis. Então, vamos ver o que é exatamente um enum. Um enum, abreviação de um tipo enumerado será na verdade nosso primeiro tipo de dados definido pelo usuário. E você verá o que quero dizer com isso no próximo vídeo, quando formos em frente e realmente criarmos um. E o que é um enum é basicamente um conjunto de grupos de valores constantes que têm um nome associado a eles que você pode usar em seu código. Ok, então é o tipo de dados definido pelo usuário. E o que é é um grupo de constantes com um valor integral. Ok? Então isso significa que ele vai puxar os números inteiros, ou um número inteiro, devo dizer, com um nome associado a ele. E como essas constantes têm um nome associado a elas, isso torna seu código muito mais legível, que é praticamente o principal caso de uso disso. E você verá um exemplo disso em um dos próximos vídeos aqui. Agora, eu sei que nós realmente não falamos sobre constantes há algum tempo. Eu também vou te dar uma breve atualização aqui. Então, o que é uma constante? Bem, é apenas uma variável que não pode ser alterada. Então, se você se lembrar de criar uma, você dirá constante e, em seguida criará uma variável normalmente. Então, podemos dizer um número constante e defini-lo como igual a cinco. Agora, algo sobre o qual eu não falei quando falamos pela última vez sobre constantes foi que, ao nomear uma constante, muitas vezes você vê pessoas e dá um nome em maiúsculas, como este para algum prefixo especial. para significar que isso é uma constante. Então, se mais tarde no meu código, eu tentei dizer números, por exemplo, e vejo, oh, ei, é tudo em maiúsculas ou vejo um prefixo específico. Eu sei que isso é uma variável constante. Eu não queria que isso mudasse nunca, certo? Porque a constante não pode ser alterada. E se ele tentar mudar isso, você receberá um erro. Então, isso é apenas algo a ser levado em conta. Isso muitas vezes você verá efeitos específicos ou letras maiúsculas no nome como apenas uma convenção básica de nomenclatura. Então, você sabe, essa é uma variável constante, não apenas minha variável média normal que eu posso mudar. Bem, de qualquer forma, isso é tudo para este vídeo. Então, a principal coisa que eu quero que você tire disso é que um ENM um tipo de dados definido pelo usuário e é um grupo de constantes com um valor integral com um nome associado a ele. Agora, quando digo com um nome associado a ele, quero dizer com cada valor integral constante, não apenas com o enum em si. E você verá um exemplo disso e um dos próximos vídeos. Como sempre, obrigado por assistir, e nos vemos na próxima. 57. Capítulo 11 (Enums): criação de um enum: Olá a todos. Neste vídeo, vamos realmente criar nosso primeiro. Agora, existem dois tipos diferentes de enumerações que você pode criar. Mas neste vídeo, vamos trabalhar apenas com o tipo mais básico. E então, em um vídeo futuro, mostrarei o outro tipo que você pode criar. E não é realmente muito mais complicado. E abordaremos as diferenças e depois também. Então, como criamos uma enumeração? A sintaxe de um tipo enum e/ou enumerado é a seguinte. Primeiro você vai dizer Ina, depois vai continuar com o nome de sua renda. E então, entre colchetes aqui, você terá cada valor que deseja associado ao seu ENM. E aqui você realmente colocará um nome de string e , em seguida, ele terá uma constante associada a ele. Agora, isso igual a 0 não é necessário ao criar um anime. Eu apenas coloquei isso aqui para mostrar a constante que foi associada a esses primeiros valores. E depois disso, este terá um associado a ele e este terá dois. E eu vou continuar subindo para obter tantos valores quanto nós temos. E eu vou te mostrar o que quero dizer com isso em um segundo. Se você estiver um pouco confuso lá. Então aqui embaixo, eu escuto, imposto para eles novamente, mas também incluí o valor constante associado a cada um deles. E podemos até criar variáveis de nosso enum, já que é um tipo definido pelo usuário apenas dizendo nosso nome EM seguido por um nome de nossa variável e definindo-o igual a um dos valores que temos associado ao nosso enum. Além disso, lembre-se de como eu disse que um enum é um grupo de valores integrais constantes. Cada um deles tem um nome associado a eles. Bem, se você se lembrar, as constantes também precisam receber um valor inicial logo no início. Assim, podemos criar uma enumeração e inicializar valores posteriormente. Precisamos fazer isso imediatamente. Então, vamos dar uma olhada em como criar um nós mesmos. Então aqui embaixo, vamos dizer, e depois vamos chamar esse, por exemplo. E muitas vezes você pode ver tipos definidos pelo usuário começarem com uma letra maiúscula. Então, vamos seguir em frente e fazer isso para nomear aqui também. E depois em colchetes encaracolados. E lembre-se de que, quando eu contar a vocês diferentes convenções de nomenclatura, você só vai querer usar o que quer que a empresa ou o que a maioria das pessoas com quem você trabalha use. Se você está apenas trabalhando sozinho , sinta-se à vontade para dar sua própria opinião sobre as coisas. Mas, de qualquer forma, damos crédito qualquer um deles dizendo Ina, obrigado por dar um nome a ele. E então, entre colchetes, vamos colocar alguns valores associados à nossa enumeração aqui. Em vez de colocar números reais, vamos colocar nomes de frutas no nosso caso. Então, podemos dizer algo como maçã, banana, laranja vírgula, mais ou menos assim. E aí está. Agora criamos uma enumeração chamada com três valores diferentes nela. E se você se lembra, eu disse que cada um realmente tem um valor constante associado a ele, que por padrão é um número inteiro. Então, se eu passar o mouse sobre isso aqui, você pode ver que a Apple está associada ao número 0, banana associada a um, laranja a etc. E isso vai continuar. E depois vamos. Não fui outro e chame isso de uvas e L1 receberá automaticamente três. Você também pode dar a eles seu próprio valor. Então, eu poderia dizer que a Apple será igual a cinco, por exemplo, então, na verdade , contará a partir daí se eu não mudar nenhuma das outras. Portanto, qualquer coisa que não tenha seu próprio valor definido aumentará apenas um em relação ao último valor definido pelo usuário. Então a Apple será cinco agora, banana, laranja, sete, uvas, oito. E eu poderia até dizer que a banana agora será igual a dez. E então ele vai subir partir daí, com laranja sendo 11. E alguém. Agora, uma coisa a ter em conta é que se eu dissesse banana igual a quatro, por exemplo, porque a laranja ainda será igual a cinco e não haverá problemas nisso. Eles podem ter os mesmos números associados a eles, mas é algo que eu quero que você seja. Ok, então você pode ir até eles todos os anos em valor e cada um que não tem um valor, vamos começar a contar a partir do último valor definido pelo usuário. Lembre-se de que matrizes e outros contêineres começarão em 0. Tudo bem, então essa é a maneira básica de criar um enum. E mais uma coisa que eu quero mostrar é que, se você se lembra, eu disse que esses valores naturalmente serão inteiros, mas podemos realmente mudar isso, se não quisermos, cada um deles para ser uma constante e lembre-se de que precisa ser um valor integral. Portanto, não poderemos mudar isso para algo como um flutuador ou um duplo, mas não podemos alterar o valor integral ao qual eles estão associados. Então, vamos fazer isso. Depois do nosso nome de enumeração, colocaremos dois pontos seguidos pelo tipo de dados que não nos foi concedido. Tem que ser uma parte integral do seu tipo de dados. Então, poderíamos dizer explicitamente int se quiséssemos, ou poderíamos dizer algo como não assinado se quiséssemos também, ou poderíamos mudar completamente o tipo. Então, podemos dizer char, por exemplo. E isso vai funcionar muito bem. Agora, todos eles têm um valor gráfico associado a eles, mas você não precisa fazer isso. Você pode simplesmente deixá-lo como está e, naturalmente, eles assumirão como padrão um número inteiro. De qualquer forma, para este vídeo e para o próximo vídeo, na verdade, criaremos um programa básico com e sem nenhum número para que você possa ver o verdadeiro caso de uso de um e como realmente usá-lo em código. Então fique atento, como sempre, obrigado por assistir e nos vemos na próxima. 58. Capítulo 11 (Enums): uso de enums: Neste vídeo, criaremos um programa básico de largura e sem enumerações, para que você possa ver o verdadeiro caso de uso deles. No caso de uso básico do E&M, é essencialmente para tornar seu código mais legível e organizado. Então, vamos começar. Portanto, o programa que criaremos neste vídeo pedirá ao usuário escolha uma fruta de uma lista de várias opções. Depois que o usuário fez uma escolha, vamos apenas significar uma confirmação de sua decisão de volta para eles. Então, vamos seguir em frente e começar. Então, primeiro, vamos começar criando uma lista de números inteiros com nomes de frutas diferentes e dar a cada um deles um valor constante. Então, vou dizer que const apple é igual a 0. Nina era uma. Laranja é igual a dois. E só faremos mais uma. Digamos que um par constante seja igual a três. Então, aqui embaixo, vamos imprimir a lista de opções para o usuário. Então eu vou dizer C para fora. Escolha nas opções da lista. Em seguida, criaremos um número inteiro junto com as entradas, então, se puderem , e depois explodiremos, isso dirá cn. Assim. Agora, criaremos um switch que relacionará sua escolha a eles. E se você se lembrar de como criar um switch, vamos dizer switch e, em seguida, terminar o parêntese. Vamos colocar a variável que estamos verificando. Então, vamos dizer comutador de entrada, e depois vamos dizer que tem gosto de 0 dois pontos. E então vamos dizer C out. E então feche com um u, mostra uma maçã. Assim mesmo. E diremos a linha M depois. E então compramos uma camisa nova que também colocamos em nossa declaração de folga. Agora, vamos copiar e colar essas quatro vezes. Tudo bem, e então aqui embaixo, quando eu defino este igual a um, este é um dos dois e esse 123 para coincidir com os valores associados aos nossos inteiros, então nós só temos que mudar o texto dentro de cada caixa aqui. Então, para o caso, alguém dirá que você escolheu uma banana. Então aqui embaixo, K é dois. Nós diremos que você escolheu uma laranja. E, por fim, dirá que você escolheu um par. E então, aqui em cima, ainda precisamos dar ao usuário uma lista de opções. Então, vamos dizer C out e , em seguida, aspas dirão um. Maçã. Em seguida, criaremos uma linha como essa. Copie e cole isso algumas vezes aqui. Nina, laranja e pêra. E nós realmente inventamos isso , este primeiro 120123. E antes de executarmos nosso código, na verdade queremos criar uma nova linha, que aparece à direita. Agora, se executarmos nosso código, podemos ver que dissemos Por favor, faça uma fruta com base na lista de opções abaixo, temos maçã, banana e laranja por par. E se digitarmos dois, por exemplo, digamos que você escolheu uma laranja, e pronto, nosso código está funcionando. Agora, quando se trata disso aqui embaixo, especialmente se você estiver trabalhando com um programa muito maior, isso não é a coisa mais razoável do mundo, certo? Estamos dizendo casos 0 e, em seguida, temos que lembrar que isso está associado à Apple, caso um. Teremos que lembrar que isso está associado à banana. E embora nosso código seja bem pequeno e isso não seja tão difícil basta verificar aqui e ler aqui. Poderíamos tornar isso muito mais legível com um enum. Então, em vez de criar uma nova constante para cada opção e, em seguida, tentar lembrar a associação com ela, vamos apenas criar uma enumeração. Então, aqui em cima, vamos apenas remover todas essas opções. E então aqui em cima vamos dizer enum, fruta. E então, entre colchetes aqui, digamos maçã, banana, laranja. Então, aqui embaixo, vamos mudar nosso número inteiro para algo como x agora. E então aqui embaixo, vamos dizer que fruta nosso tipo de dados definido pelo usuário neste enum aqui que acabamos de criar, chamado esse enclave e o definiu como igual a x. Agora, vamos obter um porque não podemos inicializar nossa variável em um número inteiro como esse, mas podemos realmente convertê-la para o tipo fruit. E isso vai funcionar muito bem. Então, se eu executar nosso código aqui, você pode ver que ele funciona exatamente como antes. Se eu escolher uma opção como três aqui, digamos que você escolheu um par, e isso porque a entrada aqui é igual ao valor inteiro desse. Mas como esse é do tipo fruta, podemos realmente usar esses valores constantes nomeados aqui. Então, aqui embaixo, eu poderia dizer “case”, “maçã”. E abaixo disso eu posso dizer banana. Então, podemos dizer laranja e pêra. E a razão pela qual isso está me dando um erro porque eu realmente escrevo banana errado. E se eu executar meu código, e agora você pode ver que isso funciona muito bem. E se eu escolher uma opção. 0 aqui, dirá que você escolheu uma maçã, e agora não precisávamos nos lembrar de nenhuma associação com ela. E, como você pode ver, isso é muito mais fácil de ler. Agora posso dizer estojo, estojo para Apple, estojo banana, par de estojos laranja. Agora, outra coisa boa sobre nosso enum aqui, ter um grupo de constantes é que nem precisávamos realmente lembrar o que eram. E eu vou te mostrar o que quero dizer. Então aqui embaixo, eu poderia ter dito o caso através do nome do nosso enum aqui e depois colocar dois pontos assim. E, na verdade, pelo menos algum Visual Studio teria me dado uma lista de nossas diferentes opções aqui. E também me mostra a constante associada a isso. Agora posso dizer que a fruta do caso era uma maçã. Eu posso ver a constante que associei a isso e simplesmente selecioná-la lá. E eu posso até mesmo escrevê-lo como tal. E isso vai funcionar muito bem. Então, isso é fantástico. Agora, com certeza aqui, só temos quatro opções se estivermos trabalhando com um programa maior e tivéssemos uma lista maior de frutas, por exemplo, teria sido muito mais fácil trabalhar com isso . Eu poderia ter dito todas as opções que inseri aqui e ter feito uma para cada uma descendo a linha. Então, como eu disse, o caso de uso básico de um ENM tornar seu código mais legível. E embora tenhamos usado apenas frutas como exemplo básico, se você está fazendo um jogo ou algo parecido, tinha um ENM de armas e deu a cada uma uma uma uma uma um identificador exclusivo de chave e valor e fez coisas que maneira apenas como outro exemplo. Agora, outra coisa boa sobre isso aqui é que, se mudássemos o valor armazenado por trás da Apple aqui por qualquer motivo, digamos que eu mude isso para algo como cinco. E esse é muito pobre. Ou o que você tem é que eu não preciso mudar isso aqui embaixo e vai funcionar muito bem. E se eu tiver alguma sobreposição, por exemplo, laranja é cinco e Apple é cinco. Também me avisará aqui que tenho dois casos que pediram o mesmo número. Então, não tem problema. Eu posso simplesmente escrevê-lo aqui. Agora, aqui embaixo, como estamos realmente criando uma lista de opções? E não queríamos ter que mudar isso toda vez que mexíamos com nossas constantes aqui, poderíamos ter feito o seguinte. Então, vou seguir em frente e remover os números desses. Então, vamos colocar tudo isso em uma ordem sequencial. Então, vamos remover tudo isso daqui. E se quiséssemos, apenas para maior clareza, poderíamos dizer, ei, esse começa em 0, mesmo que isso aconteça por padrão. Mas você verá algumas pessoas fazerem isso. Então, vou seguir em frente e mostrar isso como um exemplo. E então aqui embaixo, porque é só imprimir maçã. E se executarmos nosso código, diremos 0 e depois apple. Então, poderíamos fazer isso para o resto, assim. E então aqui, poderíamos simplesmente dizer que o par espacial, como vimos a maneira laranja e eles investem, nós amostramos. Agora, se executarmos nosso código, na verdade, isso só imprimirá essas opções para nós. E mesmo se tivéssemos alterado os valores aqui, nosso código ainda funcionaria bem, o que é muito bom. E também podemos ver explicitamente com o que estamos trabalhando aqui quando imprimimos as diferentes opções. Então, aqui em cima, se eu mudar isso para dez, todos os meus valores são diferentes e executar meu código. Minhas opções foram alteradas dinamicamente com ele e ainda é muito legível em nosso código. De qualquer forma, basicamente será isso para este vídeo. Espero que agora vocês tenham uma compreensão básica de como criar um enum e seu caso de uso está tornando seu código mais legível e mais dinâmico. Em alguns casos, como você viu aqui, fornecendo um grupo de constantes nomeadas que você pode usar em seu código e também fornecendo um tipo de dados definido pelo usuário com o qual trabalhar. Agora, a última coisa que quero mostrar rapidamente é que, como cada um dos nossos nomes de constantes de enum tem um valor real associado a eles, você pode fazer algo como o seguinte. Então, aqui embaixo, eu poderia dizer verdade. E vou colocar isso no nosso caso. Eu direi que maçã é igual a Apple. E, a propósito, eu poderia ter dito maçã, e isso teria funcionado também. Então aqui embaixo, eu vou dizer fruta, banana é igual a isso. E então eu posso realmente criar uma declaração if que funcione com a matemática por trás delas. Então, posso dizer que se a Apple é maior do que banana e, em seguida, executar algum código aqui, porque a Apple tem um número menor associado a ser um dez versus um 11, então esse código não seria executado. Mas se eu for em frente e virar essa rodada, digamos que eu comprei uma banana maior. Isso vai funcionar muito bem. E, na verdade, vou passar isso aqui rapidamente para o topo do nosso código, assim como imprime sem problemas, mas abaixo da nossa enumeração aqui. E se eu executá-lo, você pode ver que diz que Apple é maior do que a banana. Mas se formos em frente e revertêssemos isso, não aconteceria. Então, eu só quero mostrar que você poderia usar enums em matemática mesma forma que faria se fosse apenas uma constante integral normal. De qualquer forma, vou me livrar desse código extra aqui. E então o que eu quero que vocês façam é salvar tudo o que temos aqui porque na verdade vamos usá-lo no próximo vídeo quando eu mostrar a vocês o outro tipo de enum e as diferenças entre esse e este. Portanto, não se esqueça de salvar o que você tem, pois vamos usá-lo no próximo vídeo. De qualquer forma, como sempre, obrigado por assistir, e nos vemos na próxima. 59. Capítulo 11 (Enums): Eums vs Aulas de Enum: Neste vídeo, falaremos sobre o outro tipo de suficiente ser uma classe de E&M, que tem apenas algumas diferenças em relação a um ENM normal, como criamos no último vídeo. Agora, se vocês se lembram do último vídeo, eu queria que vocês salvassem todo o código que criamos para uso neste vídeo. Mas se por algum motivo, você esqueceu, nada demais, a única peça principal que eu quero vocês guardem agora é que esta é a criação real de nosso enum. E vou continuar comentando o resto por enquanto. Então, deixe-me mostrar algumas outras coisas sobre enumerações regulares antes de analisarmos como criar uma classe de enum e as diferenças. Primeiramente, se tentarmos criar uma variável com o mesmo nome de qualquer uma de nossas constantes aqui, em vez de nossa suficiente, obteremos um erro. Então, se eu disser que int orange, por exemplo, é igual a 0 ao tentar executar meu código, isso vai me dar um erro. E isso porque, por exemplo, uma enumeração regular é considerada no escopo. Então, todos esses nomes são essencialmente usados em nosso programa. E você pode ver aqui embaixo que diz que a fruta está dentro do escopo e que seria preferível usar uma classe de enum em vez do suficiente nesse caso. Agora, a outra coisa com enumerações regulares é que uma variável de enum, estamos implicitamente convertidos em um número inteiro. E deixe-me mostrar isso agora mesmo. Então aqui embaixo, se eu for em frente e remover isso, tudo bem. Eu não vou passar por toda a minha equipe e fazer com que seja igual para provar. Ok? E aqui embaixo, posso dizer que x é igual a cinco mais menos. Então, se eu imprimir x, assim, receberei t plus. Eu poderia simplesmente ter definido n igual à minha fruta. E isso teria funcionado também. E isso converterá implicitamente esse valor em isso. E se é isso que você quer, ótimo. Mas se fizéssemos disso uma classe de enum, ela não se converteria implicitamente dessa forma. E eu vou te mostrar isso agora. Então, como criamos uma classe de enum? Bem, é bem fácil. E então o mesmo enum seguido pelo nome de seu enum, classe enum, seguido pelo nome do nosso genoma. Agora, como você pode ver, imediatamente recebemos um erro e ele não será convertido implicitamente de nossa classe enum aqui, sendo fruto para um valor inteiro. No entanto, ainda podemos fazer isso explicitamente dizendo: Ei, vá em frente e faça disso um número inteiro. Isso é muito bom. Se executarmos nosso código, ainda obteremos dez. Então, ao torná-la uma classe, você não fará conversões implícitas do seu tipo de enum, dois outros tipos. Em vez disso, você terá que fazer isso explicitamente. Além disso, não usa esses nomes. Então eu poderia realmente ter chamado essa maçã, por exemplo. Isso funcionaria muito bem. Isso porque nossa enumeração agora tem um escopo essencialmente definido. E esses nomes são locais desta classe aqui, e entraremos nas aulas mais tarde no curso. Mas, por enquanto, saiba que agora podemos ter dois o mesmo nome sem problemas aqui. E isso pode ser útil se tivéssemos outra classe de E&M, por exemplo, queríamos ter nomes semelhantes. Então, talvez eu tenha tido uma aula de enum chamada comida. Então, dentro daqui, eu tinha alguns alimentos diferentes com os quais queria trabalhar. Eu poderia dizer frango, batatas fritas de maçã assim. E isso funcionará muito bem sem problemas, ao passo que não funcionaria com enumerações regulares. Portanto, existem algumas das diferenças. Basicamente, se você usar um nome e uma classe enum, ainda poderá usá-los em outro lugar. Considerando que se você usá-lo apenas com um ENM normal, você também não pode, enums regulares podem implicitamente ser convertidos para outros tipos, enquanto uma classe de enum não pode e você precisa fazer isso explicitamente, o que ajude a garantir que é isso que você quer que ele faça. Então aí está. Veja como criar uma classe de enum versus uma E&M e agora você conhece as diferenças. Então, como sempre, obrigado por assistir e nos vemos na próxima. 60. Capítulo 12 (funções): introdução de funções: Neste vídeo, falaremos sobre funções. Agora, uma função ou um método é essencialmente apenas um bloco de código que é executado somente quando está frio. Então, como eu disse, uma função é essencialmente apenas um bloco de código, como se tivéssemos um bloco de código aqui. O funciona somente quando está frio. E, na verdade, estamos usando várias funções diferentes para coisas diferentes. Por exemplo, usamos várias funções diferentes quando falamos sobre contêineres em vídeos anteriores. Além disso, praticamente todo o nosso código foi escrito nessa função principal, que, como eu disse antes, todo programa C plus plus precisa de uma função principal porque ela é chamada logo no início do programa quando seu programa começa e termina. E esse é o bloco de código que é executado quando está frio. Então, por que quereríamos usar e/ou criar uma função? Bem, primeiro, ele vai limpar seu código. Uma das razões pelas quais a limpa nosso código é porque sempre que você tem, digamos, um bloco de código que você usa, sei lá, três vezes ou mais ou algo parecido. Em vez de ter todo esse bloco de código copiado e colado várias vezes, você pode simplesmente criar uma função que nos permite usar o código repetidamente sem precisar copiá-lo e colá-lo. E outro motivo pelo qual você pode querer usar uma função é porque, por exemplo, digamos que tínhamos um bloco de código que usamos repetidamente. E nós simplesmente copiamos e colamos, copiamos e colamos , copiamos e colamos onde precisávamos. Bem, e se no futuro, você perceber, você sabe o que, eu preciso que isso faça. Algo um pouco diferente agora. Bem, agora você terá que encontrar todo o seu código que você usou repetidamente e ajustá-lo em todos os lugares individualmente. Já se você tivesse uma função, você poderia simplesmente ajustá-la. Então, basicamente, funciona dinamicamente. Em todos os lugares ele é usado. O código mudou porque podemos simplesmente mudar a função em vez de precisar alterar cada parte do código que usamos repetidamente. Tudo bem, então, apenas para resumir uma função e nosso método como um bloco de código que é executado somente quando é chamado em alguns dos principais motivos pelos quais você gostaria de usar uma função em primeiro lugar é limpar melhore seu código para torná-lo mais dinâmico. E para que você possa facilmente usar o código repetidamente sem precisar reescrevê-lo. De qualquer forma, espero que isso lhe dê uma compreensão básica do que é uma função e quando você gostaria de usá-la. Mas se você não entender totalmente, não se preocupe, pois criaremos e trabalharemos com exemplos diferentes nos próximos vídeos. Então, de qualquer forma, obrigado por assistir, e nos vemos na próxima. 61. Capítulo 12 (funções): criação de uma função: Neste vídeo, vamos criar e trabalhar com uma função muito básica. E então, nos próximos vídeos, trabalharemos lentamente com funções cada vez mais complexas para que você possa ter uma boa noção de como usar e criar suas próprias funções . E isso porque as funções são usadas o tempo todo na programação. E, pessoalmente, encontro funções e, ou métodos, como você quiser chamá-los. Tão útil que nem vou tocar ou trabalhar com uma linguagem de programação que não tenha isso. E isso porque isso limpa muito seu código. Isso o torna muito mais dinâmico e é muito mais fácil de trabalhar e menos propenso a erros do que copiar e colar código repetidamente. E na programação, você sempre quer fazer tudo o que puder para evitar erros humanos porque todo mundo comete erros. E às vezes pode levar muito tempo para descobrir o que está causando o problema. De qualquer forma, chega desse discurso retórico, vamos em frente e criar uma função básica própria. Então, aqui embaixo, fora da nossa função principal, vamos seguir em frente e criar uma função própria. Para começar, vamos colocar nosso tipo de retorno, e é isso que você quer recuperar do método. Por exemplo, nosso método principal aqui é um tipo de retorno de um número inteiro. E é por isso que, no final de todos os nossos programas, retornamos 0, que é um valor inteiro. Então, quando o método principal é chamado, ele tem um número inteiro do tipo retorno e retornamos o inteiro de volta. E isso deve ser feito agora em C plus plus, se vocês se lembrarem, vocês podem realmente remover essa linha de código. E o C plus realmente fará isso por você, pelo menos com seu método principal, sem que você precise ter essa linha de código tão especificamente. Mas eu só quis dizer deixá-lo lá para que vocês entendam que, ei, temos um tipo de retorno int, precisamos retornar um número inteiro. Além disso, quando nossa função principal retorna 0 e C plus, sabemos que todo o nosso código foi executado com sucesso e conseguimos chegar ao fim aqui. E poderíamos ter simplesmente colocado um 0 aqui também. Mas também podemos ter esse excelente sucesso aqui se você quiser que seja explicitado de forma mais explícita. Então, vamos seguir em frente e realmente criar essa coisa. Primeiro, começaremos com um tipo de devolução. Nesse caso, vamos dizer vazio. E o que significa vazio é que, Ei, não queremos retornar nada dessa função. Só queremos executar o código dentro dele. E isso está perfeitamente bem. E começaremos a trabalhar com diferentes tipos de devolução e com um próximo vídeo. Mas, por enquanto, simplesmente não retornaremos nada da nossa função. Então, vamos apenas executar o código dentro dele. Em seguida, vamos chamar isso de impressão. Assim mesmo. Depois, teremos parênteses abertos e fechados. E depois disso, teremos nosso bloco de código, que mais uma vez é definido apenas com colchetes abertos e fechados. Todo o código dentro dele é nosso bloco de código. Agora, esta parte superior aqui é nossa declaração de método ou função. Então, como acontece com as variáveis, como podemos declarar e inicializar uma variável. Aqui, podemos declarar uma função. E então, em nosso bloco de código, é onde realmente definimos nossa função. Então, aqui embaixo, ou bloco de código aqui, seria nossa definição de função. Ok, então esta é a nossa declaração e o que é inserir bloco de código é a nossa definição. Agora, vamos colocar algum código aqui para que possamos ver como isso funciona e colocar o que quisermos aqui. Mas vamos continuar e imprimir “Olá”. Como nossa função se chama print hello, então, de volta ao nosso método principal, na verdade não chamamos essa função ou ela não fará nada. Então, como você pode ver, se executarmos nosso código agora, ele não imprimirá nada. E isso porque, como falamos no último vídeo, uma função é um bloco de código que só é executado quando é chamada. Então, como chamamos nossa função? Bem, vamos dizer o nome da nossa função, seguido por parênteses abertos, depois parênteses fechados e ponto e vírgula. Agora, não é assim que você sempre chama uma função. E abordaremos algumas das diferentes maneiras quando começarmos a falar sobre argumentos e parâmetros. Mas chamar nossa função aqui, é exatamente assim que é feito. Primeiro, não estamos coletando nada a partir de suposições, então não preciso salvar nada em nenhum lugar e não temos nada entre parênteses. Portanto, não precisamos de nada entre parênteses aqui. Deixe-me simplesmente colocar um ponto e vírgula no final. E se tentarmos executar nosso código, você pode ver que recebemos um erro. Isso porque, assim como com qualquer outra coisa em C plus plus, você não pode usá-lo antes de ser definido. E uma maneira de corrigir isso é, na verdade copiando todo o código aqui embaixo, e eu o coloco acima da nossa função principal. E agora, se executarmos nosso código, você pode ver que ele não funcionará e imprimir olá. E vamos em frente e quebramos a linha M aqui. E só para mostrar isso, podemos realmente copiar e colar o quanto quisermos. E podemos colocar isso em qualquer lugar do nosso código e ele funcionará bem. E como você pode ver, imprimimos “Olá” para cada vez que invocamos nossa função. Agora, essa é uma função bem básica que realmente não funciona muito, mas você tem a ideia de uma que indica claramente o que estamos tentando fazer. Vamos apenas imprimir olá porque fornecemos nosso método. Aqui está nossa função um nome muito definitivo do que essa função faz. Além disso, se tivéssemos muito mais código aqui, por exemplo, se estivéssemos imprimindo como um parágrafo ou algo parecido, começaria a parecer muito confuso se escrevêssemos isso aqui a cada um tempo ou copie e cole, pois seriam muitos textos sem nenhum ganho em comparação com apenas dois. Algo assim, em que podemos simplesmente ter nome da nossa função, como sub t, lembramos que esta é a nossa função. De qualquer forma, é basicamente isso para este vídeo. Como eu disse nos próximos vídeos, vamos trabalhar lentamente com funções cada vez mais complexas até detalharmos todas as coisas básicas que você precisará para criar funções. de sua autoria. Então, para encerrar este vídeo, vamos recapitular rapidamente as principais coisas que você vai querer tirar disso primeiro para criar uma função muito simples e/ou básica, você pode ter seu tipo de retorno seguido pelo nome, abra e feche parênteses e, em seguida, seu bloco de código e colchetes. E, assim como com qualquer outra coisa, nosso código é lido de cima para baixo. Portanto, ele precisa saber qual é a nossa função antes de podermos usá-la. Além disso, se não retornarmos nada de uma função, podemos simplesmente dizer vazio. Então, para chamar uma função ou realmente usá-la, precisamos dizer o nome da nossa função seguido por parênteses abertos e fechados, pelo menos nesse caso, porque não há nada entre nossos parênteses aqui. E por último, um ponto e vírgula. Agora, se você ainda está um pouco confuso sobre como usar as funções, não se preocupe com isso. Você verá mais alguns exemplos nos próximos vídeos. Agora, antes de ir para o próximo vídeo, salve tudo o que você tem, pois vamos usá-lo no próximo vídeo quando falarmos sobre os protótipos da função. De qualquer forma, isso é tudo para este vídeo. Como sempre, obrigado por assistir, e nos vemos na próxima. 62. Capítulo 12 (funções): protótipos de funções: Neste vídeo, vamos criar algo chamado de função ou protótipo de método. Agora, vá em frente e mostre o que é isso. Se você se lembra no último vídeo, quando nosso método, declaração e definição aqui, estamos abaixo, não conseguimos chamar nosso método. E isso porque nosso programa não tinha ideia do que estávamos falando. Porque, se você se lembrar, o código é lido de cima para baixo. Então, vamos em frente bem rápido. Podemos mover isso de volta para baixo, nossa função principal. Assim. Se tentarmos executar isso, você verá que recebemos um erro. E diz que o print hello não foi encontrado. Não tem ideia do que estamos falando. Agora. Poderíamos simplesmente fazer o que fizemos antes, obviamente, pegando toda a nossa função e simplesmente lançando-a acima da nossa função principal. No entanto, muitas vezes, ao abrir seu código, você só quer verificar o que está na função principal. Esperamos que você consiga entender como o código funciona e como ultrapassar uma tonelada de outros métodos, potencialmente, dependendo da complexidade do seu código, pode ser realmente irritante e bagunçado. Então, para corrigir esse problema, podemos usar algo chamado protótipo de função, e isso é muito fácil de fazer. Então, vamos fazer é copiar aqueles que estão na linha superior do nosso método. Em seguida, cole-o acima nosso método principal e coloque um ponto e vírgula no final. E esse é um protótipo de função. Isso é praticamente tudo o que temos que fazer. E agora, quando nosso código é lido de cima para baixo, ele dirá: Oh, ok, há uma função chamada print hello, e a definição está aqui embaixo. Agora, quando o chamamos, ele sabe do que estamos falando. E se executarmos nosso código, você pode ver que ele funciona muito bem. Agora. Esse é um protótipo de função. E se você quiser uma explicação mais detalhada do que é um protótipo de função, ele é essencialmente como outra declaração e precisa ter o tipo de retorno, se houver, o nome junto com qualquer perímetro. em ordem. E entraremos em bitters em um vídeo posterior. Mas como não tínhamos nenhum aqui, simplesmente colocamos nossos parênteses abertos e fechados. E, por fim, basta seguir com o ponto e vírgula. E isso permite que o compilador, ou aquela coisa que traduz todo esse código em binário para que o computador possa entendê-lo, saiba o que esperar no futuro. Então, quando temos uma chamada de função mais tarde, ele já sabe a que essa chamada de função está se referindo, sendo essa função aqui, a raiz declarada e a avisou com antecedência. E tudo o que ele faz, essencialmente, desde que nossa definição seja definida posteriormente em nosso código. Porque, como eu disse, muitas vezes quando você está abrindo seu código, você só quer ver a função principal e entender o que está acontecendo. Você não quer ter que lidar com muitos outros textos de antemão. Você só quer chegar ao cerne das coisas. De qualquer forma, espero que tenha sido muito fácil de entender. Caso contrário, também trabalharemos com eles nos próximos vídeos. Porque eu sempre recomendaria usar apenas um protótipo de função em vez de colocar sua função sobre sua função principal, mesmo que funcione da mesma forma, é muito mais limpo. Então, basicamente, lembre-se de que se você quiser ter sua definição de função mais tarde, que eu sempre recomendaria, tudo o que você realmente precisa fazer é copiar essa linha superior aqui, colá-la acima, e coloque um ponto e vírgula e você vai de qualquer maneira, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 63. 62: Neste vídeo, falaremos sobre os tipos de devolução. Agora, se você se lembrar de criar uma função muito básica, começará com o tipo de retorno, seguido pelo nome, parênteses abertos e fechados e, em seguida, seu bloco de código. Agora, nos vídeos anteriores, nós apenas dissemos que não queríamos que ela entregasse nada, inserimos a palavra-chave void. Mas neste vídeo, vamos realmente dar uma olhada em como recuperar um valor de nossa função e criar uma função que também faça isso. Então, vamos seguir em frente e começar. Agora, para começar, vamos criar nosso protótipo de função. Então, para fazer isso, vamos colocar um tipo de retorno, que será int, seguido pelo nome, que será retornado dez. E lembre-se, isso pode ser o que você quiser. A propósito, a convenção de nomenclatura típica para uma função é usar camelCase, assim como fazemos com variáveis, mas para começar com uma letra maiúscula, teremos parênteses abertos e fechados e um ponto e vírgula no final, pois esse é o nosso protótipo de função. Agora, se eu passar o mouse sobre isso, você pode ver que isso nos avisa que não temos uma definição para nossa função. Mas, como você pode ver, a linha ondulada está em verde, o que basicamente significa que seu código ainda será executado. Mas ei, isso é só um aviso. Basicamente, se executarmos nosso código, não obteremos nenhum erro. O código funciona perfeitamente. Portanto, isso é mais um aviso do que um aviso real de que um código não será executado corretamente. É por isso que está em verde em vez de vermelho, pelo menos no Visual Studio. Então, para realmente criar nossa função, copiaremos tudo isso, exceto o ponto e vírgula, e colaremos abaixo. Em seguida, teremos colchetes encaracolados abertos e fechados assim. E colocaremos nosso código aqui. E podemos ter o que quisermos dentro do nosso bloco de código mais uma vez. Mas, nesse caso, simplesmente retornaremos um valor de dez. Então, hoje, tudo o que vamos fazer e dizer tempo de espera, seguido por dez e um ponto e vírgula no final. E aí está. E se passarmos o mouse sobre isso, você pode ver que isso é realmente um valor inteiro, então temos apenas nosso ponto e vírgula no final. E se quisermos que seja ainda mais explícito sobre isso, poderíamos afirmar algo como int dez é igual a dez e, em seguida, retornar essa variável diretamente. Mas o que tínhamos aqui está ótimo. Então, assim como no nosso método principal, onde ele retorna um número inteiro usando essa palavra-chave de retorno. Lembro-me que isso aqui é essencialmente o mesmo que dizer retorno zero. Então, tudo o que você precisa fazer para retornar um valor de uma função. Basta inserir o tipo de dados que você deseja retornar antes do nome da função e, em que você deseja retornar antes seguida, usar essa palavra-chave de retorno e todas as letras minúsculas, seguidas pelo valor que você deseja retornar. E você deve garantir que esse tipo de dados seja igual ao seu tipo de devolução. Então, aqui em cima, podemos ir em frente e coletar esse valor. Agora, só para mostrar uma coisa aqui, se formos em frente e chamarmos a função deles dizendo mais uma vez o nome da nossa função, seguido por parênteses de abertura e fechamento. Como não temos nada aqui, não precisamos de nada aqui. Em seguida, colocando um ponto e vírgula no final e executando nosso código, você pode ver que ele funciona perfeitamente. No entanto, sempre que você tiver uma função que retorna um tipo de dados, você deseja armazenar esse valor em algum lugar. Porque se você não vai armazenar esse valor, você pode muito bem não ter devolvido nada em primeiro lugar. Então, aqui em cima, diremos que algo como int x é igual a return ten. E então, abaixo, vamos imprimir x, assim, se executarmos nosso código, você pode ver que agora ele é igual a dez. Isso porque definimos x igual ao resultado dessa função. E como ele retorna um número inteiro, recebemos um inteiro de volta. Então, tudo o que fizemos foi criar uma variável chamada x e defini-la igual ao que nossa função aqui retorna. E se eu passar o mouse sobre essa função, você pode ver que ela retorna um valor inteiro. Então x será igual ao número inteiro retornado pela nossa função aqui, que neste caso é. Portanto, essa linha aqui é exatamente a mesma que se disséssemos que x é igual a dez. Pelo menos nesse caso, podemos simplesmente trabalhar com nossa variável normalmente. Então aí está. Agora você já sabe como usar um tipo de retorno ao criar uma função. Basicamente, em vez de dizer vazio aqui, você coloca o tipo de dados que deseja retornar. Em seguida, em sua função, você diz return seguido pelo valor do tipo de dados que você deseja que ele retorne. Agora, sempre que você chamar essa função, ela devolverá esse valor desse tipo. E é por isso que conseguimos fazer o seguinte sem problemas. Para aqueles que se lembram, x aqui é uma variável local porque ela foi declarada dentro de um bloco de código, só está disponível dentro desse bloco de código depois de ser declarada. O que significa que poderíamos ter dito algo assim aqui embaixo. X é igual a dez, e então disse X retornado. E isso funcionaria muito bem porque, no que diz respeito a esse bloco de código, x aqui não existe. E no que diz respeito a esse bloco de código, esse x aqui embaixo não existe e, portanto, eles podem ter o mesmo nome exato sem problemas. Só algo para anotar. Você sempre quer tornar as coisas tão disponíveis quanto você absolutamente precisa. Se não precisássemos fazer um x aqui, uma variável global, por exemplo, então você não gostaria de fazer isso. Você só quer disponibilizá-lo conforme necessário. Então, por exemplo, você não tem problemas em ter nomes de variáveis sobrepostos. E em segundo lugar, você também está minimizando o erro humano. Estou criando uma variável ou o que quer que ela seja, apenas tão disponível quanto ela precisa estar, o que é sempre uma coisa boa. Agora, para mostrar uma última coisa aqui, porque isso pode ser essencialmente qualquer tipo de dados que desejamos. Poderíamos retornar algo como um legal, a propósito, observe que se nosso protótipo de função aqui tivesse uma declaração diferente da nossa função real, obteremos um erro. Então, você deve ter certeza de dar esses dois o mesmo tipo de retorno, assim. E então, dentro daqui, poderíamos dizer que algo como piscina é verdade, igual a verdadeiro e depois retornar verdadeiro. Agora, isso é essencialmente o mesmo que se não tivéssemos isso e apenas disséssemos retorno, verdade. Vou seguir em frente e fazer dessa maneira, só para mostrar que poderíamos simplesmente jogar a região variável aqui. E então aqui em cima, poderíamos ter tido uma declaração if, se devolvesse dez. E provavelmente gostaríamos de renomear isso para algo como retornar verdadeiro. Só para deixar isso claro. Essa função funciona quando estamos lendo nosso método principal. Porque você nem sempre quer se preocupar com o código dentro do grau de função. Você só quer ser capaz de, como eu disse no passado, ler sua função principal e ter uma compreensão geral do que está acontecendo. Então, aqui, dissemos se fosse verdade. Observe que, ao chamar essa função, como era uma condição de instrução if, não precisávamos colocar um ponto e vírgula aqui. E então, abaixo, podemos colocar colchetes se retornar verdadeiro, executar esse código e diremos apenas a declaração C out if ou algo parecido. E se executarmos nosso código, você pode ver que isso funciona muito bem. E se tivéssemos mudado isso para falso, por exemplo e executado nosso código, ele não teria sido executado. Portanto, ao retornar um valor booleano, você também pode usá-lo diretamente em sua declaração if como condição aqui. Então, isso é muito legal. Portanto, lembre-se de que existe uma função para facilitar sua vida. E então isso é essencialmente o mesmo ter o valor booleano aqui, já que ele retorna um booleano e quando retornamos um int, era o mesmo que ter o valor int lá, já que retorna um número inteiro. Então aí está. Espero que agora você tenha uma compreensão básica de como trabalhar com os tipos de devolução. Caso contrário, você sempre pode assistir novamente ao vídeo. Caso contrário, você verá mais exemplos disso nos próximos vídeos. Então, obrigado por assistir, e nos vemos na próxima. 64. Capítulo 12 (funções): parâmetros e argumentos: Neste vídeo, vamos dar uma olhada nos parâmetros e argumentos. Agora, no passado, criávamos algumas funções básicas parecidas com essa. Eles tinham um tipo de retorno seguido pelo nome, parênteses abertos e fechados e, em seguida, nosso bloco de código e colchetes. Mas dentro desses parênteses, podemos realmente ter a lista dos chamados parâmetros. Então, poderíamos dizer se o parâmetro um, parâmetro dois, etc. E podemos ter quantos quisermos. E quais são esses nossos valores que planejamos passar para a função. Assim, podemos realmente enviar dados para a função , bem como recuperar dados da função. Então, vamos dar uma olhada em como fazer isso. Então, aqui abaixo da nossa função principal, vamos criar uma função que soma dois números e nos dá o resultado disso. Então, para fazer isso, vamos citá-lo neste caso. E então diremos adicionar ao nosso nome. E então, entre parênteses, diremos int x vírgula y, assim mesmo. E então teremos nosso bloco de código e explicarei por que fizemos isso aqui em apenas um momento. E então, dentro do nosso bloco de código, dirá return x mais y. Agora, poderíamos ter criado uma variável inteira chamada result e, em seguida, retornar o resultado. Mas eu só quero mostrar que poderíamos ter uma expressão em nossa declaração de retorno aqui, porque ambas são números inteiros, ela retornará um inteiro. E agora, quando realmente chamamos nossa função, podemos fazer o seguinte. Então, primeiro, vamos imprimir o resultado dessa função. Então, para fazer isso, vamos apenas dizer C pelo nome da nossa função aqui. E então, entre parênteses, você pode ver que precisamos colocar dois valores inteiros. E os valores que colocamos em nossa chamada de função aqui são chamados de argumentos, enquanto que aqui embaixo, chamaremos os perímetros. Então, aqui podemos dizer algo como 510. E então esses números serão enviados para nossa função aqui, depois serão somados e retornados para nós como um número inteiro. E então, antes de executar um código, porque nosso método está abaixo da nossa função principal aqui, só precisamos criar um protótipo. Então, copiaremos essa linha superior, colaremos acima e colocaremos um ponto e vírgula. Então, agora temos um protótipo de função. Temos uma chamada de função aqui e também temos uma declaração e definição de função aqui embaixo. Então, se executarmos nosso código aqui bem rápido, você pode ver que ele imprime 15. Isso porque dissemos: Ei, queremos imprimir esse valor inteiro que recebemos daqui. Esse foi o nosso tipo de devolução aqui. Em seguida, passamos dois valores inteiros como argumentos para esses parâmetros. E tudo o que fizemos foi dizer: Ei, devolva o primeiro mais o segundo. E, a propósito, os argumentos que passamos aqui são os valores que passamos aqui e precisam estar na mesma ordem que esses aqui embaixo. Então esses dez nunca tomarão o lugar de x, e esses cinco nunca tomarão o lugar de y. Eles estarão em ordem, e na mesma ordem em que estavam aqui embaixo, precisavam estar nessa ordem aqui em cima também, é por isso que muitas vezes é mais fácil copiar essa primeira linha e depois adicionar um ponto e vírgula no final ao criar seu protótipo de função. Além disso, só para que você saiba que esses nomes de parâmetros são locais para essa função. Portanto, você ainda pode criar um inteiro x aqui em cima e um int y, e ele funcionará bem. Ok? Portanto, eles são locais da função que foram criados. Então, basicamente, para criar um parâmetro, tudo o que você precisa fazer é ter o tipo de dados seguido pelo nome. E todo esse nome é o nome com o qual você deseja trabalhar para o valor passado para sua função. Então, você criará um perímetro sempre que quiser passar algo para sua função. E o que você passa é chamado de argumento e está associado ao mesmo parâmetro em ordem. Portanto, temos 510 aqui, que serão associados a X e Y respectivamente. Então esses cinco valem para x e o tempo era para quê? Como eu disse, pudemos dar a eles o nome que quiséssemos, mesmo que tivéssemos criado duas variáveis aqui. Então, se quiséssemos, poderíamos ter dito int x ou num one. Num dois é igual a dez e depois passado no número um, num dois. E isso vai funcionar muito bem. Como eu disse, esse nome de parâmetro aqui, é exatamente o que você deseja chamar de valor ou argumento passado dentro de sua função. E eles poderiam ter o mesmo nome se quiséssemos que fosse assim e isso teria funcionado também. Mas como eu disse, você pode chamar isso do que quiser. Então, tínhamos apenas x e y os nomes com os quais queremos trabalhar para os valores passados para que pudéssemos usá-los em nosso livro de códigos. Além disso, outra coisa a observar é que esse parâmetro é uma cópia dessa variável e não da variável em si. Então, se e aqui eu dissesse x plus plus, e então aqui em cima imprimimos o número um. O número um não seria alterado. Então imprimimos 16 porque passamos em 510. Em seguida, aumentamos x em um, o que era igual a cinco originalmente. Então, cinco a 66 mais 1016. E então imprimimos o número um, que ainda estava bem. E isso porque, como eu disse, esse perímetro aqui é x, apenas uma cópia do argumento passado, que era o número um. E a perda de maiúsculas e minúsculas, o que significa que mudar x na verdade não altera a variável, e é também por isso que, se isso fosse uma constante, por exemplo, isso funcionará bem porque não tentamos mudar o constante, nós apenas mudamos a cópia do ser. Então, espero que tudo tenha feito sentido. A principal coisa que eu quero que você tire disso é que você pode passar valores para uma função criando um parâmetro ( I) apenas declarando o tipo de dados seguido por um nome que você deseja trabalhar. com dentro da função. E então o valor que você passou é chamado de argumento e será copiado para uso em sua função. Então, você só precisa se certificar de que todos os parâmetros que você tem aqui também estejam colocados em seu protótipo e agora também sejam necessários quando você chama a função. Portanto, não poderíamos ter dito add num one, pois receberíamos um erro dizendo: ei, isso realmente requer mais argumentos, certo? Então aí está. Agora você sabe como trabalhar com parâmetros e argumentos em C plus plus. Agora vou remover o CEO número um, e removê-lo para essa constante aqui, assim. E o que eu quero que vocês façam é realmente salvar tudo o que temos aqui, porque vamos usá-lo no próximo vídeo. De qualquer forma, obrigado por assistir, e nos vemos no próximo. 65. Capítulo 12 (funções): argumentos opcionais: Neste vídeo, falaremos sobre argumentos opcionais. Agora, se vocês se lembram do último vídeo, pedi que dissessem tudo o que tinham para que pudéssemos usá-lo neste vídeo aqui. Agora, se por algum motivo você não assistiu ao último vídeo ou esqueceu de salvar, fique à vontade para pausar o vídeo e copiar tudo isso. De qualquer forma, vamos dar uma olhada nos argumentos opcionais e seus casos de uso. Então, para tornar um argumento opcional, tudo o que precisamos fazer é definir aqui em nossa declaração de função o parâmetro igual a algo. Mas quando fazemos isso, temos que começar com o mais à direita e ir para a esquerda. Então, deixe-me mostrar o que quero dizer com isso. Então, eu posso dar um valor padrão de 0. Então, obteremos um erro aqui. Mesmo argumento padrão, não no final da lista de parâmetros. E é por isso que você sempre tem que começar com o mais certo. Então, como você pode ver, se eu definir y igual a 0, tudo ficará bem. E então podemos trabalhar até o de qualquer um dos parâmetros que queremos que tenha um valor padrão. E isso também os tornará opcionais. Então agora, aqui em cima, onde eu disse adicionar número um , número dois, eu posso simplesmente removê-los completamente. Então, temos que fazer uma última coisa antes executar nosso código para não cometer nenhum erro. Ou seja, temos que pegar nosso método completo aqui e colocá-lo no topo, assim. E isso vai funcionar muito bem. Então, se executarmos nosso código aqui, você pode ver que imprimimos um. E isso porque temos esse x plus plus aqui. Mas se prosseguirmos e removermos isso rapidamente, você pode ver se imprimimos 0 e não precisamos passar nenhum argumento, pois os argumentos eram opcionais porque nossos parâmetros têm um valor padrão. Agora, a outra opção seria deixar nossa função onde a tínhamos. Assim mesmo. Remova esse valor padrão para nossos parâmetros em nossa declaração de função aqui embaixo e, em vez disso, coloque-o no protótipo da função. E não, você não pode tê-lo em ambos. Então, se você tiver um protótipo de função, é para lá que seus valores padrão precisam ir. E há diferentes razões para isso, que eu realmente não vou abordar. Mas saiba que se você quiser ter um argumento padrão, você precisa dar ao seu perímetro um valor padrão de ajuda, começando com o que está mais à direita e voltando para o voltando para máximo padrão. argumentos como você gostaria. E se você tiver um protótipo de função, esses valores padrão precisam ir lá e não entrar na nossa definição de função. E agora, se nos livrarmos deles aqui novamente e executarmos nosso código, podemos ver que imprimiremos 0. Podemos alterar esses valores para o que quisermos, como y é igual a cinco, e agora ele imprimirá Oi. Tudo bem, então vamos dar uma olhada em um exemplo melhor de quando você pode querer usá-los. Então, vamos nos livrar da nossa função aqui. E então também vamos nos livrar de tudo aqui e remover nosso protótipo de função para começar com uma tela em branco, como. Então, aqui em cima, vamos criar um protótipo para essa função. E o que vamos fazer, digamos vazio, texto, parênteses abertos e fechados e um ponto e vírgula no final. E então, dentro daqui, vamos usar uma sequência de caracteres como argumento. Então, precisamos de um parâmetro de string e vamos chamar esse texto assim. Em seguida, vamos criar a declaração e a definição reais da função abaixo. Então, vamos colar isso aqui sem o ponto e vírgula e criar nosso bloco de código. E então diremos apenas CL. E então vamos seguir em frente e dar ao nosso texto aqui um valor padrão. E porque temos um protótipo de função que vai ter que ir até aqui. Então, logo após os textos dizerem igual a, Você não enviou uma string. A função. Então, isso nos permitirá chamar nossa função, mas nos avise de que na verdade não inserimos nenhum texto. Agora, nesse caso, poderíamos simplesmente não ter um valor padrão e, em seguida, ele não nos permitiria chamar a função sem inserir texto. Mas vamos fazer isso dessa maneira apenas para dar um exemplo de como você pode usá-los. E então, aqui embaixo chamaremos nosso método. Então, vamos dizer texto impresso. E então vamos continuar e realmente enviar um texto aqui. Então, vamos dizer imprima texto, olá, mundo, ponto e vírgula no final e execute nosso código. E, como você pode ver, imprimimos Hello world. E se não colocarmos nada aqui e ao redor do nosso código, agora ele dirá que você não enviou uma string para a função. Então aí está. Agora você já sabe como criar argumentos opcionais. E para resumir, você pode fazer isso fornecendo um ou mais parâmetros, um valor padrão começando da direita e subindo para a esquerda, seja na declaração da função aqui ou se você tem seu protótipo de função , ele precisa ir até lá. E, a propósito, apenas um aviso, o motivo pelo qual temos que começar da direita e trabalhar para a esquerda, sem o fato de que receberemos um erro e ele não nos permitirá executar nosso código, é o seguinte. Então, digamos que depois disso, eu fui em frente e peguei um número inteiro e vamos chamá-lo de x e defini-lo como igual a 0. Em seguida, removeremos o valor padrão do texto aqui. E aqui embaixo diremos x, assim. Então, abaixo, diremos C para os textos, e também imprimiremos x assim. E vamos seguir em frente e renomeá-los até o final. E se quiséssemos ser mais explícitos aqui, ok? E agora, se começarmos a colocar argumentos aqui, passarão automaticamente da esquerda para a direita, porque lembre-se de que eles devem estar em ordem. Então, quando eu coloco um texto como baixo. E agora esse argumento de string hello aqui irá automaticamente para o nosso primeiro parâmetro. Mas como nos permitiu fazer isso dessa maneira? Bem, então não teríamos como dar um valor a x sem dar um valor ao texto. De qualquer forma, o pôr do sol é feito em ordem. De qualquer forma, espero que tudo tenha feito sentido para vocês. Caso contrário, vocês sempre podem falar comigo na seção de discussão abaixo, e eu entrarei em contato com vocês assim que puder de qualquer maneira. Obrigado por assistir, e nos vemos na próxima. 66. Capítulo 12 (funções): funções sobrecarregadas: Neste vídeo, falaremos sobre algo chamado sobrecarga de funções, que é onde você tem várias funções com o mesmo nome, mas argumentos diferentes. E eu vou te mostrar por que você gostaria de fazer isso com um exemplo aqui. Então, vamos criar uma função para somar números. Então, aqui embaixo, vamos dizer int. E, em seguida, parênteses NR, diremos int x vírgula y, exatamente assim. E então, em nosso bloco de código aqui, diremos return x mais y. Vamos também colocar nosso protótipo de função no topo. Então, vamos simplesmente copiar isso, colar acima e colocar um ponto e vírgula aqui. E lembre-se de que, se quiséssemos alguns valores padrão aqui, eles teriam que subir aqui. Então, apenas copiar e colar, não funcionaria. Teríamos que adicionar algo como x é igual a 0 e y é igual a 0. Agora, vamos sobrecarregar essa função para obter um conjunto diferente de argumentos. Então, para fazer isso, vamos copiar esse método e colá-lo abaixo, assim mesmo. Em seguida, diremos vírgula e z. Lembre-se de que podemos chamar isso do que quiséssemos. E então diremos que retorna x mais y mais z. Em seguida, copiaremos essa linha superior aqui, colaremos acima e colocaremos um ponto e vírgula no final. E aí está. Agora temos duas funções separadas e seus respectivos protótipos de função que têm o mesmo nome, mas argumentos diferentes. E isso é chamado de sobrecarga de funções. Agora, aqui em nossa função principal, posso dizer algo como CL, adicionar o nome da nossa função. E no Visual Studio aqui pelo menos você pode ver que eu tenho duas opções. E se eu passar o mouse sobre isso, diz mais duas sobrecargas. Mas isso me avisa que nenhuma instância da função sobrecarregada chamada add corresponde à lista de argumentos. E isso porque eu não coloquei nada aqui. Mas agora você pode ver que eu tenho uma função de adição que leva dois em valores, e eu tenho uma segunda função de adição que assume, ou seja. Eu poderia dizer algo como cinco vírgula cinco. Certifique-se de colocar um ponto e vírgula no final aqui e executar meu código. E você pode ver que imprimimos dez, e isso funciona muito bem, sem problemas. Mas eu também poderia adicionar outro valor inteiro agora e ver isso. Imprimimos 15. Portanto, essa função de adição é um exemplo perfeito de quando você pode querer fazer algo assim. E eu posso fazer quantos desses eu quiser. Então, eu poderia usar essa função de adição para adicionar quantas variáveis inteiras eu gostaria. Outra coisa que poderíamos ter feito era usar um tipo de dados totalmente diferente. Então, vamos copiar nosso método de adição aqui novamente e colá-los abaixo, entre os outros dois, assim. E em vez de dizer digite tudo isso, vamos seguir em frente e dizer flutuar. Em seguida, copiaremos nossa linha superior. Cole aqui para criar um protótipo. Não esqueça o ponto e vírgula no final. E agora eu posso colocar variáveis flutuantes em que isso funcionaria muito bem. Como se fosse uma vírgula 5.5 3.3 ou algo parecido. E execute nosso código. Agora obteremos 8,8, assim mesmo. Então, isso é muito legal. E esse é mais uma vez um exemplo perfeito de quando você gostaria de usar a sobrecarga de funções, porque agora eu posso ter uma função chamada apenas add. Não preciso me lembrar de vários nomes de funções diferentes. E eu posso jogar carros alegóricos, eu poderia jogar uma polegada. E eu também posso ter diferentes quantidades de números ou variáveis que eu colocaria lá. E eu não vou ter nenhum problema , desde que eu tenha criado uma declaração e uma definição para cada conjunto de argumentos que eu gostaria de usar. E se quiséssemos, poderíamos até ter dado um desses, como o nosso primeiro aqui, valores padrão. Então, aqui em cima, eu poderia ter dito que x é igual a 0 e y é igual a 0. E isso também funcionará bem. Então, agora eu não poderia ter nada aqui, ou eu poderia ter criado outra função de adição que simplesmente não aceitasse argumentos nesse caso. Mas você quer ter cuidado ao fazer isso, porque se eu tivesse feito o mesmo com esse aqui, talvez ele não soubesse de qual eu estava falando em primeiro lugar. Então, eu fiz algo assim durante todo o tempo? Bem, agora não tenho mais certeza que estou falando, porque agora essa chamada de função de adição funcionaria para mais de uma instância da função sobrecarregada. Portanto, esse é um problema concedido neste caso, todos eles estão definidos como 0. Então, quem se importa se imprimirmos 0? Mas você receberá um erro, obviamente. Portanto, nosso código não será mais executado até resolvermos esse problema. Então, só queria te avisar sobre isso. De qualquer forma, isso é tudo para este vídeo. Espero que agora você tenha uma compreensão de como as funções sobrecarregadas funcionam e quando você pode querer usá-las. Obrigado por assistir, e nos vemos na próxima. 67. Capítulo 12 (funções): recursão: Neste vídeo, falaremos sobre algo chamado recursão, onde algo basicamente invoca a si mesmo. E faremos isso com uma função que nos dará o fatorial de um número. Se você não sabe o que é isso, deixe-me ir em frente e te mostrar rápido. Então, fatorial de um número é algo assim. Então, digamos que demos a ele o número cinco, E fatorial 45. Aqui estaria o seguinte. Seria cinco vezes o número abaixo dele. Então, quatro vezes o número abaixo disso é três vezes duas vezes um. E isso nos daria o fatorial de cinco. Então, você basicamente vai multiplicar o número que você coloca por esse número, vezes um abaixo disso, até obter um, multiplicá-los completamente e isso lhe dará o seu fatoriais. E, na verdade, usaremos cinco no método criaremos, apenas para que você saiba que ele está funcionando corretamente. Então, se formos em frente e fizermos isso em uma calculadora aqui e digamos cinco vezes, quatro vezes três vezes duas vezes um, você pode ver que obtemos 120. Tudo bem, então vamos criar uma função que faça isso. Agora, existem algumas maneiras replicar isso em código, mas faremos isso com recursão, onde temos algo chamado por si mesmo. Então, vamos seguir em frente e criar um exemplo disso. Então, aqui embaixo, vamos criar um método que nos dará o fatorial de qualquer número que inserirmos nele. Então, aqui embaixo, diremos enter e chamaremos isso de fatorial. E então, entre parênteses, diremos número. Então, em nosso bloco de código aqui, diremos que se o número for maior que um, queremos fazer o seguinte, que é retornar número vezes. E então vamos invocar o método fatorial novamente, assim. Aqui, diremos o número de menos um. E então, aqui embaixo, vamos criar uma declaração outra como essa e dizer senão, devolva uma. Agora, isso pode parecer um pouco confuso, mas vamos criar outro método que faz a mesma coisa sem recursão. E então eu vou tentar separar os dois da melhor maneira possível. Espero que tudo faça sentido em como isso está funcionando em segundo plano. Mas primeiro, vamos criar nosso protótipo de função antes que nos esqueçamos. Então, vou colar acima e colocar um ponto e vírgula. Agora, abaixo, isso criará um outro método para, digamos, n fatorial. Vamos chamar isso de fatorial dois, por exemplo, digamos número int. E esse é um exemplo perfeito de quando você pode simplesmente querer dar a ela uma variável o mesmo nome de outra, porque ela é muito legível. Eles não estão nem um pouco conectados. O escopo final está incluído na função, portanto, menor. E então, dentro do nosso bloco de código aqui, vamos dizer o seguinte fatorial. Um. Em seguida, criaremos um loop for e diremos que int I é igual a um, enquanto ouço dizer que é menor ou igual ao número I mais, mais. E então, entre colchetes, dirá que tempos fatoriais são iguais a I, como. Então. Então, fora disso, vamos em frente e retornaremos. Isso deve fazer exatamente a mesma coisa. Então, antes que eu esqueça, vamos criar um protótipo desse tipo. Então, agora, aqui embaixo, vamos usar esses dois métodos. Então, diga a linha fatorial CL. E, em seguida, abaixo dessa média fatorial de ACL para a linha N. Não esqueça os parênteses aqui, assim. E então adicionaremos cinco para esses dois. Ok, então eu vou ampliar as clínicas aqui, vocês podem ter certeza de que seu código corresponde ao meu aqui. E vamos seguir em frente e executar isso. Então, como você pode ver, temos o 120º para ambos os nódulos, que foi o fatorial para o HIV. Agora, na realidade, nenhuma dessas funções parece muito ruim, mas isso é apenas um exemplo de uso da recursão de funções para concluir uma tarefa. Então, o que realmente está acontecendo aqui embaixo do capô, pois isso pode parecer um pouco confuso para alguém, bem, primeiro dissemos que se o número fosse maior que um, então se tivéssemos o exemplo de cinco aqui, Bem, cinco é maior do que um? E a resposta é sim, é. Então, o que vamos fazer é retornar o número sendo cinco vezes o fatorial do número abaixo dele. O que isso vai retornar um número inteiro. Mas quando esse passar, vai dizer que é para mais de um. Sim, é. Então, agora queremos quatro vezes o número abaixo disso, e isso vai continuar acontecendo até finalmente cheguemos a um ponto em que o número é um. E então ele só vai devolver o quê? Você precisa ter certeza de que eu eventualmente tenho essa recursão aqui, vamos parar e que isso não acontecerá infinitamente. Caso contrário, sem entrar em muitos detalhes aqui, estamos afetando muito as ervas daninhas aqui. Você ficará sem memória e terá alguns problemas porque está criando uma, outra função dentro de uma função, dentro de uma função. E isso só aumenta e aumenta, e então, eventualmente, você se depara com problemas. Então, vamos dar uma olhada no que está acontecendo. Então, para fazer isso, vamos começar com o último caso. Então, no final de tudo isso, teremos uma função que diz, ok, queremos retornar duas vezes um, porque isso será o que voltará da função aqui. Uma vez que isso seja igual a um, porque o número não é maior que um, porque seria um, ele retornará um. Então, no final, retornarei duas vezes um. Então, a função que estava tentando obter o resultado dessa equação aqui, bem, eu tenho três vezes, três vezes dois, que depois caiu para dois, um. Em seguida, a função acima disso. Teremos quatro vezes três, assim. E, eventualmente, teremos cinco vezes o resultado de tudo isso. Então, essencialmente, agora temos a função que acabou de retornar um. Então temos uma segunda função que fez essa matemática aqui, uma terceira do que uma quarta quinta função. Então, agora criei cinco funções sozinhas apenas inserindo essas cinco aqui. Então, o que acontecerá é a primeira função, retornaremos apenas uma. O segundo retornará um valor de dois, o próximo um valor de seis e depois 24. E por último, cinco vezes 24 nos dá 120. Então aí está. Foi assim que obtivemos nossa resposta final. Agora, espero que isso tenha feito sentido. Caso contrário, fique à vontade para entrar na Internet e examinar mais sobre recursão e outros exemplos, trabalhar com eles e realmente detalhar o que está acontecendo. Agora, como eu disse, você deve ter cuidado para não criar muitas funções ao fazer isso. E você também quer ter certeza de que isso não acontecerá infinitamente pelo mesmo motivo que você ficará sem memória em algum momento. Então, nesse caso, esse foi o nosso ponto de parada em que, uma vez que o número não era mais maior que um, apenas retornávamos a um. E esse ponto de parada aqui é chamado caso base quando se trata de recursão. Então aí está. Espero que agora você tenha uma compreensão básica do que é a recursão de funções e saiba como usá-la e as coisas com que ter cuidado ao usá-la de qualquer maneira. Então, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 68. Capítulo 12 (funções): matrizes como parâmetros: Neste vídeo, falaremos sobre passar matrizes como argumento. Mas antes de fazer isso, quero mencionar uma coisa. Então, já falamos sobre tipos e funções de retorno, mas eu quero que você saiba quando você tiver essa instrução de retorno e passar algo de volta para a cor, o que quer que esteja chamando sua função, nenhuma senha de código será executada. Então, é como sair da inocência. Então, aqui, vou dizer CL, olá, assim, e executar nosso código. Nem vai ler isso. Não vai imprimir isso porque já temos uma declaração de devolução. Então, quando você cria uma função que tem um tipo de retorno, observe que, uma vez que você tenha uma instrução de retorno, ela deixará de ler o código e sua função e voltará para o chamador ou o local onde você chama sua função em primeiro lugar. Portanto, se você tiver várias declarações if ou algo parecido, poderá ter várias declarações de devolução e isso funcionará perfeitamente. Só queria avisar que uma declaração de retorno também pode ser vista como uma declaração de interrupção que retorna um valor. Então, vamos dar uma olhada em como as matrizes são passadas como argumentos. Primeiro, vamos seguir em frente e criar uma matriz. Então, vamos definir minha matriz entre colchetes aqui. Só vai dar a isso um tamanho de cinco. E vamos seguir em frente e dar cinco valores logo de cara aqui. Então, diremos 1234. E então vamos criar uma função que imprimirá uma matriz. Então, vamos dizer void, print array, assim, depois inserir parênteses aqui, criaremos um parâmetro que usa uma matriz como argumento. Então, ainda teremos que ter o tipo de dados normalmente. Então, teremos um nome aqui com o qual queremos trabalhar em nossa função, como de costume. E então teremos colchetes abertos e fechados para significar que isso é uma matriz e não apenas um número inteiro. E, abaixo, criaremos nosso bloco de código aqui para nossa função. Então, aqui embaixo, vamos imprimir todos os elementos da nossa matriz. Então, vamos dizer que eu é igual a 0, eu menos que cinco, eu mais, mais. E então, entre parênteses, estava um CEO. E então nosso nome de parâmetro sendo ARR do que n colchetes dirá: Eu criarei uma nova linha. E agora, se estiver aqui em nossa função principal, que você também pode ver como nossa cor, já que é o que chamaremos de nossa função PrintArray. Podemos dizer matriz de impressão e , em seguida, entre parênteses , passar minha matriz. Então eu posso colocar um ponto e vírgula. Observe que não colocamos nenhum colchete aqui em nosso argumento ou nenhum número. Agora, antes de executar um código, simplesmente precisamos criar um protótipo de função aqui na parte superior e executá-lo. Você pode ver que imprimimos 12345. Agora, observe que colocamos o tamanho aqui explicitamente. E isso não é ótimo porque não é muito dinâmico. Mas o problema é que não poderíamos colocar um tamanho como nosso argumento aqui. Então, para corrigir isso, o que você gostaria de fazer é dizer tamanho da vírgula ou algo parecido. Lembre-se de que você pode nomear isso como quiser e colocar menos que o tamanho aqui. E aqui em cima, gostaríamos de mudar nosso protótipo. E então colocamos o tamanho aqui. E isso funcionaria bem alto. Como você pode ver, imprimimos 12345. E essa é a melhor maneira de passar uma matriz como argumento, porque ter a matriz e, em seguida, esses dimensionam uma variável separada, pois isso funcionará e dinamicamente agora. Então, agora, se definirmos, nossa matriz terá um tamanho de sete, por exemplo. E então eu estou aqui. Temos mais dois elementos assim e os alteramos aqui. Nossa função ainda funcionará como queremos. Agora, algo que você pode fazer é colocar um tamanho aqui, assim. E isso também funcionará bem. O problema é que se o tamanho da nossa matriz mudar aqui, você não poderá acessar esses outros valores porque ele não saberá do que você está falando. Então, se aqui embaixo, eu disse que CL está sendo o nome do nosso parâmetro aqui, e então coloquei sete, por exemplo, e execute nosso código. Você pode ver que recebemos uma resposta muito estranha. E isso porque, no que diz respeito, nossa matriz tem um tamanho de cinco. Podemos apenas pedir o sétimo elemento e não vamos realmente entender por que isso aconteceu. Mas saiba que, embora isso fosse possível, o que fazíamos antes era que tínhamos apenas um tamanho em branco aqui. E então, uma variável de tamanho separada é a melhor maneira de fazer isso. Agora, a outra coisa interessante sobre o uso de uma matriz como parâmetro é que ela é realmente passada por referência e abordaremos as referências posteriormente. Mas, basicamente, quando estávamos trabalhando com variáveis como parâmetros, ela era passada por valor e estávamos criando uma cópia dela. Eu demonstrei em um vídeo anterior, mas com matrizes, elas são passadas por referência. E isso porque N C plus plus você não pode passar uma matriz por valor e criar uma cópia dela. E não vamos entender por que isso acontece, mas essencialmente porque isso é passado por referência, na verdade não estamos criando uma cópia dessa matriz e estamos essencialmente trabalhando diretamente com a matriz. Então, agora, se eu dissesse que ARR indexado 0 é igual a dez, assim no final da nossa função aqui, e depois imprima-o. Minha matriz indexa 0, assim, e executa nosso código, você pode ver que imprimimos dez. E isso porque, embora estivéssemos trabalhando com nosso nome de parâmetro aqui, porque as matrizes são passadas por referência. Como eu disse, entraremos em referências em um vídeo futuro. Basicamente, somos capazes de trabalhar com o original em vez de uma cópia dele. Então, se mudarmos algo aqui com nosso perímetro, também mudaremos o original. Então, basicamente, a principal coisa que eu quero que você tire deste vídeo é que se você quiser usar uma matriz como parâmetro, você fará o seguinte. Você terá o tipo de dados das matrizes seguido por um nome com o qual deseja trabalhar. E então use seus colchetes para indicar que é uma matriz. Você vai querer ter uma variável separada para o tamanho real dessa matriz. Além disso, as matrizes são passadas por referência, o que significa que quando mudamos algo usando nosso nome de parâmetro aqui, também mudaremos o original. Então, fazendo algum planejamento, isso muda o original, pois aqui não é uma cópia como quando se trabalha com outros tipos de dados. Então, só para mostrar isso novamente, se disséssemos que x é igual a sete e, em seguida, passamos x como nossa variável inteira e, em seguida, alteramos o valor do tamanho aqui dizendo tamanho mais, mais e depois imprima fora x aqui embaixo. Vamos seguir em frente e jogar isso em uma nova linha para que fique um pouco mais óbvio. Você pode ver que ainda temos sete. E isso porque outros tipos de dados, quando usados como argumento, são passados por valor. E, portanto, o tamanho aqui é apenas uma cópia desse valor e não terá nenhum efeito no original. Mas uma corrida é aprovada especificamente por referência, o que basicamente significa que vamos trabalhar com o original e não criar nenhuma cópia. Então, quando mexemos com nosso perímetro aqui, também estávamos mexendo com o original. Espero que isso tenha feito sentido. Caso contrário, não se preocupe, na verdade falaremos sobre referências no próximo vídeo. Então, a única coisa que você realmente precisa tirar deste vídeo é como usar uma matriz como parâmetro. Primeiro, você quer dizer que está usando uma matriz usando os colchetes junto com o tipo de dados dessa matriz, e você dará esse nome de parâmetro como de costume, então você precisa ter um variável para o tamanho dela porque não pode ser aston com o argumento aqui. Então, só precisamos colocá-lo separadamente. E, por fim, saiba que as matrizes são transmitidas especificamente por referência, o que significa que, se você mexer com o parâmetro aqui, você está essencialmente mexendo com o original. De qualquer forma, espero que tenham gostado. Obrigado por assistir, e nos vemos na próxima. 69. Capítulo 13 (Referências): Introdução às referências: Neste vídeo, apresentarei uma breve introdução às referências. Tudo bem, então eu mencionei um pseudônimo ou outro nome para outra coisa. Então, por exemplo, muitas pessoas têm apelidos. Então, digamos que seu nome era Jonathan. As pessoas podem chamá-lo de John e estão se referindo à mesma coisa. Então, neste exemplo, John estaria em uma referência a Jonathan, estivesse falando sobre a mesma pessoa. E isso é basicamente o que uma referência em C plus plus também. Então, por exemplo, podemos ter um número inteiro chamado x, e digamos que seja igual a 0. E então podemos ter uma referência chamada apelido ou algo parecido. Apenas como um exemplo terrível, isso é igual a x. E agora podemos dizer que x é apelidado aqui, e falaremos sobre a mesma coisa. E se definirmos x apelido igual a cinco mais tarde. Então, se aqui embaixo eu dissesse x apelido é igual a cinco. Agora x seria igual a cinco porque estou me referindo exatamente à mesma coisa. Portanto, uma referência é apenas um pseudônimo ou outro nome para outra coisa. E veremos alguns exemplos, além de como realmente criar um para si mesma nos próximos vídeos e analisaremos alguns dos diferentes casos de uso de referências, para que você saiba como para usá-los em seus próprios programas. De qualquer forma, espero que tudo isso faça sentido e, como sempre, obrigado por assistir e nos vemos na próxima. 70. Capítulo 13 (Referências): criação de uma referência: Neste vídeo, vamos criar uma referência básica. Então, vamos dar uma olhada em como isso aconteceu. Portanto, a sintaxe para nossa referência é a seguinte. Primeiro, você terá o tipo de dados. Outra coisa que você fará referência. Em seguida, você seguirá com o símbolo do e comercial, como SO, seguido pelo nome da referência. E então você o definirá como igual ao nome de referência, que é algo ao qual você está se referindo. Ok, então vamos em frente e realmente criar um aqui. Vamos dizer que int x é igual a cinco. E, abaixo disso, diremos int ampersand. E vamos chamar isso de X igual a X. Ok? Portanto, temos o tipo de dados da coisa a que estamos nos referindo mantido pelo símbolo e comercial e, em seguida, o nome da nossa referência. E você pode chamar isso do que quiser, seguido pelo nome. Agora, se você se lembra no último vídeo, eu disse uma referência, então há apenas um pseudônimo para falar sobre a mesma coisa. Então, agora podemos usar raio-X ou nosso nome de referência aqui para fazer qualquer coisa com x que pudéssemos apenas dizendo x. E isso significa que aqui embaixo, eu poderia dizer algo como x ref é igual a dez. E se continuarmos imprimindo x agora, assim, ele imprimirá dez. E poderíamos até mesmo imprimi-lo, se fossem referenciados diretamente. E isso também imprimiria dez. Então, uma referência como apenas um pseudônimo ou outro nome para a coisa a que está se referindo. Isso e isso são essencialmente a mesma coisa. Agora, também uma coisa que eu quero mencionar é que você não pode declarar uma referência e inicializá-la mais tarde. Precisa ser feito na mesma linha, mesma forma que as constantes, por exemplo, funcionam, porque você também não pode alterar sua referência posteriormente. Então, se eu disser que y é igual a dez, não posso alterar x ref para ser igual a quê? Bem, eu poderia dizer que extra é igual a y, mas isso na verdade mudaria x. Isso não seria um apelido para y agora, e você pode ver isso se eu imprimir x ref e x aqui na mesma linha, e, em seguida, criaremos uma nova linha. Em seguida, mudaremos y para ser igual a 15. E então aqui embaixo diremos C e imprimiremos mais. Por quê? Assim, se eu executar meu código aqui, você pode ver que imprimimos dez porque extra foi definido como igual a x, que era cinco. E então definimos x basicamente igual a y, agora x é igual a dez. Então, imprimimos dez porque f e x extras são a mesma coisa. E então imprimimos dez novamente, porque mais uma vez, esses dois são essencialmente a mesma coisa agora, então mudamos o y para 15, mas quando o imprimimos, X ref ou x, Basicamente ainda eram dez e y tinha 15, então imprimimos 15 depois. Então, espero que isso faça sentido. Uma vez que você disse que eu referenciei igual a alguma coisa, você não pode mudar isso. Depois dessa linha, nossa referência é gravada em pedra. Extra sempre será o equivalente a x e vice-versa, que é y, x mudará o dez quando mudarmos x ref a hora. Ok, então aí está. É assim que você cria uma referência básica. Tudo o que você vai fazer é dizer o tipo de dados da coisa a que você deseja se referir, seguido pelo símbolo e comercial, então você terá o nome da sua referência e poderá chamá-la de qualquer coisa você gostaria. E então você terá o que ele vai se referir. E aí está, de qualquer maneira. Obrigado por assistir e nos vemos na próxima. 71. Capítulo 13 (Referências): Referências e loops de foreach: Neste vídeo, falaremos sobre referências mais uma vez, mas falaremos especificamente sobre o uso de referências com para cada loop. Então, vamos dar uma olhada nisso. Primeiro, vamos criar uma matriz de números inteiros. Então, diremos int minha matriz, então teremos alguns colchetes aqui. E depois disso, vamos em frente e adicionaremos alguns números. Então diga um, vírgula dois. Ok, então temos uma matriz int de tamanho cinco com cinco valores diferentes. Lembre-se, se você quisesse, você poderia colocá-lo aqui também. Portanto, é mais fácil de ler. Quantos valores estão em sua matriz, mas você não precisa. Em seguida, vamos imprimir tudo à nossa direita e ao nosso loop foreach como fizemos no passado. E peço desculpas por usar os mesmos exemplos repetidamente em vários vídeos. Mas o objetivo é apresentar apenas uma coisa nova cada vez para que vocês possam entender melhor tudo. Tudo bem, então aqui, criaremos um para cada loop e diremos quatro. Ou poderíamos dizer automático, se você se lembrar, já que queremos o mesmo tipo de dados do nosso contêiner de qualquer maneira, e então diremos x dois pontos na minha matriz, assim. E então, entre colchetes, colocaremos nosso código, por exemplo, CL x, e criaremos uma nova linha depois disso. Agora, se eu executar nosso código aqui, você pode ver que isso está funcionando muito bem. 12345. Agora, se quiséssemos alterar o valor normalmente das coisas em nossa matriz, isso não funcionaria. E isso porque X é apenas uma cópia desses valores aqui. Não podemos dizer que x é igual a cinco e esperar que isso altere os valores reais desses índices. Então, se executarmos nosso código, você pode ver que vamos imprimir 55 vezes. E então, se imprimirmos nossa matriz novamente, então, se copiarmos isso aqui e imprimirmos novamente, removeremos esse x é igual a cinco linhas. Você verá que isso não mudará. Então você imprime 55 vezes, depois imprime 12345 sendo os valores armazenados em nossa matriz. No entanto, se fizermos disso uma referência à nossa matriz ou a outro nome para nossa taxa, se você quiser, isso funcionará. Então, tudo o que precisamos fazer é depois de automático aqui, vamos colocar o símbolo do e comercial exatamente assim. E agora x será uma referência real a esses valores, o que é bem legal. Então, se executarmos nosso código, novamente, você pode ver que imprimimos 510 vezes porque, à medida que ele foi executado, X era na verdade o mesmo cada uma dessas variáveis aqui. E embora eu tenha mencionado no último vídeo que uma referência não pode ser alterada, o que realmente está acontecendo aqui é que toda vez que ela percorre nosso código, ou para cada loop está criando uma referência chamada x, definindo-o igual ao índice 0 na primeira vez. E, em seguida, executando esse código, vou criar uma outra referência chamada x e defini-la como igual ao índice um. E segue em ordem, assim mesmo, criando uma nova referência a cada vez que não existe mais após nosso bloco de código. Portanto, não se preocupe com nada lá. E por ser uma referência, podemos alterar os valores originais. Agora, a outra grande vantagem das referências é que , como estamos trabalhando com o original, não estamos criando uma cópia que pode ficar muito cara. Então, por exemplo, se eu apenas inicializasse cada valor na minha taxa para 0 e então eu tivesse uma matriz de tamanho de mil. Isso vai funcionar muito bem. E se eu corresse, isso seria impresso em mil valores. Mas como isso foi passado por referência, basta alterar o valor e imprimi-lo. Mas como não passamos por referência, como fizemos aqui. Na verdade, tivemos que criar uma cópia de todos os mil valores e depois imprimi-la. E agora estamos trabalhando com números inteiros, e essa é a única coisa em nosso programa, então não foi tão ruim assim. Mas quando você está trabalhando com tipos de dados maiores e mais informações, isso pode ficar muito caro. Então, fazer algo assim aqui é mais eficiente. Então, há outro exemplo de quando usar uma referência e como ela pode trabalhar com cada loop. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 72. Capítulo 13 (Referências): Referências como parâmetros: Neste vídeo, falaremos sobre referências mais uma vez, mas falaremos especificamente sobre referências como parâmetros. E se você se lembra de um vídeo anterior, já tínhamos trabalhado com matrizes sendo passadas por referência, mas agora vamos passar outros tipos de dados por referência também. Então, vamos dar uma olhada em como isso é feito. Primeiro, vamos criar uma variável inteira aqui. Então, digamos que int num um é igual a cinco. E depois, abaixo disso, vamos imprimir o número um, sem mais nem menos. Então, aqui embaixo, criaremos um método e diremos void, o que significa que não precisamos de um tipo de retorno. E diremos definido como dez, por exemplo. E então, entre parênteses, pegaremos um número inteiro e o chamaremos de x. Dentro daqui, diremos que o texto é igual a dez. E então criaremos um protótipo para nossa função acima. Portanto, não esqueça o ponto e vírgula. E então tudo o que precisamos fazer é chamar nossa função aqui. Estamos dizendo definido para dez. Parênteses abertos e fechados colocarão um dentro e um ponto e vírgula no final. E se executarmos um código, ele imprimirá cinco. E isso porque outros tipos de dados fora das matrizes são passados por valor. Ou seja, quando colocamos num um aqui como nosso argumento, x era igual ao valor de num um sendo cinco. Então dissemos que essencialmente cinco é igual a dez. Bem, isso não mudou nada. É por isso que, quando imprimimos em um, ainda estava bem. Mas se passarmos por referência colocando o e comercial na frente do tipo de dados aqui. E também temos que fazer isso em nosso protótipo. Bem, agora x é um apelido ou um pseudônimo, ou uma preferência, ou o que você quiser chamar de número um. Então, quando nosso código foi executado, dissemos, ok, vamos criar uma referência chamada x e defini-la igual a tudo o que é passado como entorpecente. Então, basicamente, dissemos que um é igual a dez. Então, quando executamos nosso código e agora o número um é dez, e isso porque x era uma referência ao que passamos. Então aí está. É assim que você pode usar referências como parâmetros. Agora, isso tem o mesmo benefício que tinha para cada loop, em que, toda vez que isso for concluído, ele criará uma nova referência e a definirá ele criará uma nova referência e a definirá como igual ao que passamos. Então, da próxima vez que chamarmos isso, se disséssemos que número dois é igual a três, por exemplo. E então copiamos nossa chamada de método aqui e colocamos duas. Então, vamos imprimir um espaço seguido por dois. Ambos serão definidos como iguais a. E isso porque toda vez que ele passa, ele cria uma nova referência chamada x e igual a qualquer argumento que passamos. Então, x não está realmente sendo alterado para uma referência diferente. É uma referência totalmente nova chamada x e, em seguida, ela não existe mais quando esse bloco de código termina. É por isso que isso funciona. Agora, o que eu quero mencionar é que você pode passar algo aqui pela eficiência e garantir que você não altere esse valor. Então, digamos, por exemplo, que estamos passando um livro inteiro de texto e esse método era imprimi-lo. Bem, não gostaríamos de criar uma cópia completa desse livro de textos toda vez que executássemos esse método. Em vez disso, provavelmente gostaríamos de fazer algo assim, em que trabalhamos apenas com o mesmo livro de texto e, em seguida, garantir que não editemos esse texto por erro do usuário em nosso bloco de código aqui, todos nós Eu tenho que fazer é dizer const. E isso nos impedirá de mexer com essa variável agora, dizendo: Ei, isso não é modificável. E isso evitará qualquer erro de usuário de sua parte ou de qualquer outra pessoa que possa editar seu código. Será muito óbvio que, ei, eu só queria uma referência à minha variável, mas não queria realmente alterar essa variável em. Então, não importa o que eu coloque nesse bloco de código, isso não vai me deixar mexer com isso agora. Assim, você pode usar a palavra-chave const para criar uma constante, mesmo que seja uma referência, apenas para ter certeza de que não é possível modificá-la. Eu só quero que isso seja lido apenas basicamente. E isso essencialmente permitirá a eficiência sem a capacidade de alterar o original. Então, isso é ótimo. De qualquer forma, isso é tudo para este vídeo. Só queria mostrar a vocês como usar referências com parâmetros. De qualquer forma, como sempre, obrigado por assistir, e nos vemos na próxima. 73. Capítulo 13 (Referências): Referências como tipos de retorno: Neste vídeo, sinto muito, mas estamos falando de referências. Mais uma vez. No entanto, desta vez, estamos falando sobre referências como tipos de devolução. Então, vamos dar uma olhada em como isso é feito, bem como no caso de uso real disso. Então, o que vamos fazer é criar uma matriz int para começar. Vamos chamar isso de minha matriz e definiremos isso como igual a 12345, assim mesmo. E vamos seguir em frente e dizer explicitamente: Ei, temos valores altos aqui. Tudo bem, agora abaixo disso, vamos imprimir tudo em nossa matriz. Dirá para auto x, dois pontos na minha matriz, assim mesmo. E suportes encaracolados de tinta. Vamos seguir em frente e X em uma nova linha a cada vez. Então, vamos criar um espaço em branco entre eles porque vamos colocar algo aqui em apenas um momento. E então, aqui embaixo, vamos criar nossa função real ou um método, se você quiser. Então, vamos dizer, seguido pelo símbolo e comercial. E então diremos que defina o valor exatamente assim para o nome da nossa função. E então, entre parênteses aqui, vamos pegar um número inteiro, então secante x. Então, teremos alguns colchetes ondulados. E então, aqui, vamos dizer virar meu índice de matriz X. E vamos em frente e, na verdade, chamaremos isso de apenas traço por índice. Agora, você notará que recebemos um erro porque nossa matriz é indefinida. Então, o que realmente precisamos fazer é pegar nossa matriz aqui e colocá-la fora de qualquer função como essa. Então, também vamos copiar nosso método aqui, ou a linha superior dele, devo dizer, para nosso protótipo assim. E agora o que vamos fazer é colocar o texto abaixo, imprimir aqui e copiar nosso loop de foreach e colá-lo abaixo, assim. E então, nesse meio tempo, vamos realmente mudar os valores de r, certo? Então, como nossa função tem uma referência como seu tipo de retorno, podemos realmente usá-la no lado esquerdo de uma expressão ou de uma declaração de atribuição nesse caso. E você verá o que quero dizer aqui em apenas um segundo. Então, vamos dizer valor definido. E então, entre parênteses, colocaremos o índice que queremos alterar. Então, vamos prosseguir e mudar esses segundos aqui. Então, diremos um, porque lembre-se os índices para contêineres começam em 0. Então, vamos mudar esse valor aqui. E então podemos simplesmente dizer iguais. Vamos prosseguir e mudar outro logo abaixo disso. Então, diremos que algum valor do índice quatro é igual a cinco. Ou vamos prosseguir e alterá-lo para algo como 33. Então, vamos dar uma olhada em todo o nosso código aqui. Primeiro, criamos uma matriz fora de qualquer função para que ela estivesse disponível globalmente nesse caso, depois tivemos nosso protótipo de função. E se formos até nossa função aqui, o que fizemos foi ter um tipo de retorno de referência int e nossa função foi chamada de valor definido e recebeu um número inteiro. E então o que fizemos foi retornar uma referência inteira do índice especificado para essa matriz específica. Então, tudo aqui à esquerda pode muito bem ter dito referência int, chamá-la de gráfico, por exemplo, é igual ao meu índice de matriz um. E isso teria sido exatamente a mesma coisa, e veremos isso em um segundo. Então, se executarmos nosso código aqui, o que vamos fazer é imprimir de um a cinco e depois imprimir um. Nosso segundo índice foi alterado para 1034 e, em seguida, nosso último índice, ou nosso elemento no índice 4. quinto elemento, no entanto, você deseja ver, foi definido como 33. Então aí está. E teria feito exatamente a mesma coisa se tivéssemos ido em frente e pegássemos isso aqui e apagássemos aquilo. E então, abaixo disso, dito é igual a dez, porque na verdade precisamos alterar o valor aqui e depois executar nosso código. Você olharia para isso, exatamente o mesmo resultado? Então aí está. Deixe-me ir em frente e desfazer isso bem rápido. Então, como você pode ver, dizer, isso era essencialmente o mesmo que dizer isso, junto com dizer que respiração é igual a dez. A única diferença aqui é que somos capazes de criar uma referência para cada índice que quisermos, apenas retornando uma referência e inserindo o índice que queremos. E então, como tínhamos uma referência como um tipo de retorno, você pode usar nossa função aqui no lado esquerdo da expressão. Então dissemos: Ei, mude minha matriz essencialmente no índice 12, o que você também poderia ter visto como dizendo meu índice de matriz um é igual a dez, que neste caso pelo menos teria sido um muito mais simples. Mas eu só queria mostrar como o uso referências como tipos de devolução funciona. Basicamente, ele apenas permite que você realmente retorne uma referência igual ao que você colocou no retorno aqui. Portanto, nossa referência inteira era igual à minha matriz, seja o que for. Então aí está. Isso é uma referência de uso como tipos de retorno. Você colocará o e comercial após o tipo de dados do tipo de retorno, tanto na declaração quanto no protótipo, e retornará o que deseja que seja uma referência. Então aí está. Em seguida, encerre este vídeo. Deixe-me mostrar como acabei de criar uma referência a um número inteiro em nosso método aqui. Então, se formos em frente e removermos tudo isso aqui, chamaremos nosso método de aluguel. E faremos o mesmo aqui embaixo. E então vamos realmente remover o argumento de ambos. Então, temos algo parecido com isso agora, e depois retornaremos x. E, para definir a seguir, criaremos uma variável global X. Agora, temos uma variável chamada x, que não está definida para nada. Mas se quiséssemos, poderíamos defini-lo como 0. E aqui, e nossa função principal, diremos envolvendo o nome da nossa função e, em seguida, abrindo e fechando parênteses, já que não temos nenhum argumento para passar e defini-lo como igual a dez. E então, abaixo, diremos x. Então, o que isso vai fazer? Primeiro, criamos uma variável global chamada x e, em seguida, dentro de nossa função principal, temos uma chamada para nossa função criada pelo usuário chamada rent by wrath. E o que isso vai fazer é retornar uma referência inteira para x. Agora, lembre-se de que isso não tem um nome, então não poderíamos usá-lo mais tarde, na verdade, mas ainda funcionará para esse caso de uso . Então dissemos para retornar por referência, o que nos dá uma referência inteira a X. Então agora isso pode muito bem ser x. Então isso foi o mesmo que dizer x é igual a dez, basicamente porque criamos um global variável chamada x. E quando chamamos nosso método aqui, ele retornou uma referência inteira para x. Então isso pode muito bem ser x, e definimos isso como igual a dez. Agora, quando imprimimos, x, x era dez. E se executarmos nosso código, você pode ver que esse é o caso. Então aí está. Espero que agora você tenha uma compreensão de como usar referências como tipos retornados. Basicamente, ele permite que você retorne diretamente uma referência. E o principal argumento disso que você pode usar seu método aqui no lado esquerdo de uma declaração de tarefa. Então você viu como fazer isso com uma variável e com um contêiner, como uma matriz. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 74. Capítulo 13 (Referências): Endereços de memória: Neste vídeo, apresentarei um detalhamento do que as referências estão realmente fazendo em segundo plano, como uma espécie de introdução ao nosso próximo tópico neste curso, que são dicas. E você verá por que eu fiz esse vídeo quando entrarmos nele. Mas, por enquanto, vamos nos concentrar apenas no detalhamento do que realmente está acontecendo com as referências. Então, para fazer isso, o que vamos fazer é criar uma variável inteira chamada x e defini-la como igual a cinco, por exemplo. E então eu vou adicionar alguns comentários aqui. Então, isso é apenas uma variável int. E, abaixo disso, vamos imprimir o endereço de memória da nossa variável inteira. E podemos fazer isso com esse símbolo de e comercial seguido pelo nome, nossa variável, e depois imprimiremos uma nova linha. Então, isso aqui vai imprimir o endereço de memória de x. E se executarmos nosso código aqui, você pode ver que é isso que acontece. Ou pelo menos confie em mim, esse é o endereço de memória de x. Eu sei que parece loucura. Não se preocupe, você não precisa detalhar isso nem nada e descobrir o que é tudo isso. Saiba que é assim que podemos obter o endereço de memória de uma variável, ok, Agora, se criarmos uma referência a x, então se eu dissesse e comercial, chamaremos isso de href igual a x. Então e em seguida, imprima ampersand ref para obter o endereço de memória do representante. Assim, também criaremos uma nova vida para essa pessoa e depois executaremos nosso código. Você pode ver que eles são exatamente os mesmos. Ok? Então, aqui criamos uma referência x e depois imprimimos o endereço da memória. Nossa próxima referência. Como você viu quando estávamos em um código, eles são exatamente os mesmos. E isso porque, como eu disse antes, uma referência é essencialmente apenas outro nome para exatamente a mesma coisa. Nada é diferente. Eles compartilham exatamente a mesma localização de memória e compartilham o mesmo valor. índice de respiração impresso normalmente imprimiria apenas cinco. E para realmente esclarecer que eles são a mesma coisa. Vou te mostrar uma última coisa aqui ao usá-la como argumento. E eu sei que falamos sobre isso um pouco no passado, mas eu vou te mostrar mais uma coisa sobre isso. Então, se você disse que x é igual a cinco e, abaixo desse crédito, uma referência a especialistas em e comercial, ref é igual a x. E então vamos criar um método aqui embaixo, e diremos void, mude int num. E em nosso bloco de código aqui, diremos que num é igual 22 e precisamos fazer um protótipo disso. Vou colocá-lo aqui, assim. E agora, se seguirmos em frente e os métodos de cores não mudarem a ira. Então, vamos passar nossa referência real a x, c out, breath. Então, o que você acha que vai acontecer? Bem, vamos ver se vai imprimir cinco. E isso porque, como eu disse, uma referência e a coisa a que ela está se referindo ou a que eles estão se referindo são a mesma coisa. Assim, podemos passá-la da mesma forma que cortamos a variável original e ela ainda não será alterada. Agora, como tomamos uma referência como parâmetro aqui, como fizemos no passado, então sim, ela mudaria para 22. E até poderíamos ter passado um x aqui e ele ainda mudará para 22 porque, como eu disse, eles são a mesma coisa. Você pode usá-los do mesmo branco. Então aí está. Só queria esclarecer que uma referência e a referência são exatamente a mesma coisa. Eles podem ser usados exatamente da mesma maneira, mas são apenas um apelido para o que quer que estejam se referindo. Eles até compartilham exatamente o mesmo valor com nossa impressão aproximada ou x. É a mesma coisa e até compartilham o mesmo local na memória. E, como eu disse, o motivo desse vídeo, além de mostrar como obter o endereço de memória de uma variável. E que você poderia simplesmente adicionar a referência aqui sem alterá-la porque você manteve a variável, se ela não fosse tomada, essa referência era para prepará-lo para o que falaremos em a próxima série de vídeos sendo indicadores. Então, espero que isso faça sentido, como sempre, obrigado por assistir e nos vemos na próxima. 75. Capítulo 14 (ponteiros): introdução a ponteiros: Neste vídeo, falaremos sobre dicas. Agora, um ponteiro, como uma referência, é usado para armazenar o endereço de uma variável em vez de apenas armazenar o valor dela em si, como as referências em que os ponteiros armazenam o endereço de uma variável. Agora, qual é o objetivo completo de um ponteiro? Bem, por um lado, ele permite que você assimile a chamada por referência. E também servem para criar e manipular estruturas de dados dinâmicas ou alocação dinâmica de memória. Agora, não vamos realmente criar e manipular estruturas de dados dinâmicas ou lidar com a alocação dinâmica de memória. Ou ele faria neste curso, só porque é um tópico muito mais aprofundado , do que eu quero me aprofundar, especificamente neste curso. Mas dito isso, ainda vamos dar uma olhada nos indicadores, como usá-los, quando usá-los e as diferenças entre isso e referências e quando você gostaria de use um sobre o outro, pois você não poderá ir a lugar nenhum na programação C plus plus sem saber quais são os ponteiros. Portanto, é importante saber o que são, como usá-los e quando usá-los. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 76. 75: Neste vídeo, vamos criar nosso primeiro ponteiro. Portanto, a sintaxe de um ponteiro é a seguinte. Primeiro, você terá o tipo de dados da variável apontada para. Muito parecido com a forma como criamos referências, onde temos o tipo de dados do que planejávamos referenciar. Você terá o tipo de dados do que planeja apontar para o quão alto é o símbolo do asterisco para significar que este é um ponteiro semelhante ao que temos o sinal comercial com referências para significar que ouvimos criar uma referência. Em seguida, você seguirá com o nome do ponteiro e, em seguida, poderá atribuí-lo a algo também. No entanto, você não precisa fornecer um valor inicial logo de cara, como fizemos com as referências. E também abordaremos isso um pouco mais tarde no curso. E ao atribuí-lo, você atribuirá a ele o endereço de uma variável. Agora, o asterisco e o C plus plus, como vimos agora, podem ser usados para várias coisas diferentes. Primeiro, eles podem ser usados para declarar que você está criando um ponteiro. Ele pode ser usado para desreferenciar um ponteiro e pode ser usado na multiplicação. E você verá alguns exemplos de desreferenciar um ponteiro aqui em breve. E então uma coisa que eu queria mostrar com este texto aqui, porque se você tem o e comercial ao criar uma referência ao lado do tipo de dados ou ao lado do nome não importa. Essas duas linhas de texto são iguais e podemos até criar uma referência para uma referência, e agora elas serão todas a mesma coisa. Então x, ref e rough to here agora são essencialmente a mesma coisa. Eles são todos apenas apelidos ou apelidos um para o outro. E se eu executar meu código aqui, você pode ver que isso funciona muito bem. Então, se você tem o e comercial aqui ou aqui, não importa. E você pode ter várias referências à mesma coisa, mas isso é suficiente sobre referências por enquanto. Eu só queria te mostrar isso bem rápido. E o mesmo acontece quando você está criando um ponteiro, o asterisco aqui, ou você pode tê-lo aqui. Não faz diferença. Pessoalmente. Gosto de tê-lo aqui, especialmente porque quando você está trabalhando com funções como vimos com referências e você tem um tipo de retorno parecido com esse. Na verdade, você não tem o nome lá, e você o tem ao lado do tipo de dados. Então, eu também gostei dessa consistência ao criar vários da mesma variável. Então, deixe-me ir em frente e remover isso rapidamente. Se eu dissesse x vírgula y, e então eu posso dizer que x é igual a cinco e y é igual a cinco. E quando você tem algo assim, onde você cria um múltiplo de uma variável na mesma linha. Você pode fazer o mesmo com referências em que você diz int x reference e why reference. Algumas pessoas gostam de ter o símbolo ao lado do nome pela consistência com isso. Mas, pessoalmente, não gosto de criar várias variáveis na mesma linha. Acho que isso só torna seu código menos legível. É por isso que eu pessoalmente o coloquei ao lado do tipo de dados. Mas se você ver o contrário, não se preocupe, é exatamente a mesma coisa, seja um ponteiro ou uma referência, não importa. mesma coisa. Agora vamos finalmente entrar no objetivo desse vídeo, que é criar um ponteiro e ver como ele funciona. Então, ele dirá que int x é igual a dez e, abaixo, criaremos um ponteiro. Então, diremos asterisco int e depois diremos P, x. Algumas pessoas gostam de prefixar os nomes dos ponteiros com um par. Então, aqui, eu estou vendo isso assim, só para você saber que é um ponteiro, mas você pode nomeá-lo como quiser. Em seguida, vamos defini-lo igual ao endereço de x, assim, lembre-se de e comercial antes de um nome de variável como esse, porque o endereço dessa variável. Portanto, nesse caso, você pode ver o e comercial como o endereço do operador. Então, criamos um ponteiro fornecendo o tipo de dados para o que queríamos apontar, colorido pelo asterisco e, em seguida, o nome do ponteiro. Em seguida, dissemos que é igual ao endereço da variável. Então, essa foi a nossa declaração e inicialização de um ponteiro para. Agora, você não precisa inicializá-lo na mesma linha em que o declara, ao contrário das referências. Então, aqui embaixo, vou recriar isso. E poderíamos ter dito int asterisco x para nosso ponteiro para x, e então simplesmente colocar um ponto e vírgula no final assim para declarar nosso 23º. E então podemos inicializá-lo mais tarde dizendo que P x é igual a comercial e x assim. E isso vai funcionar muito bem. Então, se eu executar meu código, você pode ver que não recebemos nenhum erro e tudo funciona. De qualquer forma, deixe-me ir em frente e desfazer isso agora. Ok, vamos imprimir nosso ponteiro. Então, se você se lembra no último vídeo, eu disse que um ponteiro é essencialmente apenas uma variável que contém um endereço versus onde uma referência contém o valor. Se isso fosse uma referência, seria basicamente o mesmo que X, mas um ponteiro contém o endereço da variável. Então, se imprimirmos isso como, como, imprimiremos o endereço aqui. E você pode ver isso aqui, e este é o endereço de x. E para provar isso, vamos continuar e também imprimir o endereço de x. Então, depois da linha n aqui, vamos imprimir o endereço de x usando o endereço do operador, se você quiser. E depois disso, o que é ótimo. Eu sou assim. E se executarmos nosso código aqui, você pode ver, ei, está nosso endereço e há exatamente o mesmo endereço. Ok? Então, o ponteiro do mouse naturalmente contém o endereço de tudo o que ele está apontando. É por isso que acabamos de imprimir o plano. Imprimimos o endereço. Agora, lá embaixo, vamos fazer o oposto. Então, o que vamos fazer aqui embaixo é imprimir o valor, o endereço de ajuda. Nosso ponteiro está apontando para o valor de x. E, na verdade, colocaremos esse código logo abaixo dele. Então, vamos dizer C para fora. E então diremos o símbolo do asterisco seguido por p de x e, em seguida, uma nova linha como essa, vou imprimir x e a luz. Então, se você se lembrar, como mencionei aqui, um asterisco também é uma área de desreferência, e o que ele permite que você faça é desreferenciar e endereçar. Então, nosso ponteiro aponta para o endereço de x, isso é o que ele contém. E então, usando esse asterisco, podemos desreferenciar isso. Então, em vez de apenas obter o endereço da variável, podemos obter o valor mantido nesse endereço. E então estamos apenas imprimindo o valor de x e eles serão exatamente os mesmos. Então, como você pode ver aqui, começamos colocando nosso ponteiro, que contém apenas um endereço, e imprimimos o endereço de x. E isso foi a mesma coisa, já que nosso ponteiro aponta para x. Então, aqui embaixo, usamos o símbolo de asterisco para desreferenciar um ponteiro e obter o valor real mantido nesse endereço. Agora, não vamos nos aprofundar muito nos endereços, na forma como tudo é armazenado. Mas observe que um ponteiro contém o endereço de uma variável e você pode obter o endereço de uma variável com esse símbolo de e comercial. Portanto, esse endereço aqui é onde nosso valor de x é armazenado. Então, nesses casos, ele é armazenado nesse endereço. E nosso ponteiro tem mesmo endereço porque foi isso que dissemos que ele fizesse. Isso. E logo abaixo, imprimimos nosso ponteiro, que, como eu disse, representa esse endereço. Aqui. Imprimimos o endereço de x, que deve ser exatamente a mesma coisa. E então usamos o símbolo de asterisco para desreferenciar um ponteiro seguido pelo nome do nosso ponteiro, que nos dá o valor real mantido nesse endereço. E então imprimimos x, assim como fizemos no passado. Então, o que isso significa sobre todas as variáveis que estamos criando? Bem, isso basicamente significa que quando dissemos Ei, vamos criar um número inteiro chamado x e defini-lo como igual a dez, que estamos criando um inteiro que contém o valor dez. E isso é armazenado em um endereço ou local na memória. E podemos acessar esse valor. Novamente, estamos nesse local na memória, se você quiser, apenas dizendo x. Então aí está. Espero que isso não tenha sido muito confuso para você. Tudo o que eu quero que você tire disso, na verdade, é que um ponteiro aponta para o endereço de uma variável. É por isso que se mantém. Então, assim como nossa variável aqui é igual a esse valor, um ponteiro contém o endereço dessa variável e também como criar um ponteiro. Mas vamos praticar um pouco mais sobre isso nos próximos vídeos. Agora, uma última coisa eu quero mencionar é que você não precisa inicializar um ponteiro ao criá-lo. Você também pode alterar para onde o ponteiro está apontando. Então, por exemplo, podemos dizer que y é igual a 15. E então aqui embaixo, depois de imprimir todas essas coisas, vamos realmente copiar tudo isso e colar. E vou criar um espaço aqui para que possamos ver as diferenças entre eles. Em seguida, removeremos a declaração. Então, esse asterisco int aqui embaixo, e diremos que Px agora apontará para o endereço de y. E então imprimiremos o x novamente junto com o endereço de y. E então aqui embaixo, vamos desreferenciar o endereço de y, que basicamente imprimirá o porquê. E imprimiremos y também. E se executarmos um código, você pode ver que isso funciona muito bem. Então, há o endereço de x e o endereço de y. E então também imprimimos o valor junto com o valor de y usando o ponteiro e usando nossa variável diretamente. Então aí está. É assim que se usa um ponteiro e um pouco mais sobre o que é um ponteiro. Obrigado por assistir, e nos vemos na próxima. 77. Capítulo 14 (ponteiros): ponteiros NULL: Neste vídeo, falaremos sobre ponteiros e nulos. E se você é membro, porque vimos saber no passado, null significa nada ou 0. Ok? Então, o que quero dizer com ponteiros? E sabe o que? Vamos dar uma olhada. Então, vamos criar uma variável inteira aqui chamada Exelon. Basta definir como igual a dez. E então vamos em frente e criaremos um ponteiro. Então, diremos asterisco p x, novamente, como fizemos no último vídeo. E vamos definir isso como igual e realmente saber o que precisa estar em maiúsculas. Só para maior clareza, vou colocá-lo aqui também. Então nulo é o mesmo que 0. Então, se eu tinha isso ou isso, não importa. É a mesma coisa. Então vá em frente e faça isso para que haja o mesmo que isso. Então, o que isso significa? E por que você quer fazer isso? Bem, sempre que você cria um ponteiro, você não quer fazer isso e depois trabalhar com esse ponteiro sem inicializá-lo em algo. É incrivelmente perigoso, pois você pode acabar sobrecarregando a memória ou travando seu programa e uma lista completa de outras coisas ruins que você não quer fazer. Então, quando você não inicializar isso imediatamente, eu sempre recomendaria configurá-lo como este. Ou como eu disse, você poderia colocar 0 para dizer: Ei, eu não estou inicializando isso agora, mas eu não vou simplesmente deixar isso ligado inicializado essencialmente. Então, basicamente, o que isso está dizendo é: aqui está um indicador, mas ele não aponta para nada na memória. E na verdade não precisávamos dessa variável inteira chamada x. Eu a coloquei aqui para mostrar o mesmo exemplo que tivemos na última frase. E agora, o que você pode fazer antes usar esse ponteiro é dizer o seguinte. Aqui embaixo. Antes de fazermos algo com nosso planeta, podemos realmente verificar se nosso ponteiro aponta para alguma coisa porque o definimos como nulo aqui. Basicamente, está dizendo que não está apontando para nada no momento. Mas, como fizemos isso, podemos fazer o seguinte. Podemos dizer que Px não é igual a nulo. Em seguida, executamos, para executar nosso código sem ter nenhum, eles estão explicitamente dizendo que ele não aponta para nada. Podemos verificar se ele está apontando para algo antes de fazermos algo com ele. Tudo bem, e isso ajudará a evitar muitos erros no futuro , porque você trabalhará com um ponteiro e não fornecerá um valor inicial, sempre o definirá como nulo e em seguida, verifique se ainda é igual a nulo posteriormente, antes de trabalhar com ele. Porque, como eu disse, você não quer trabalhar. Se for assim com o ponteiro do mouse e for muito perigoso. Então, se você não vai inicializá-lo, sempre defina-o como nulo, basicamente dizendo explicitamente que isso não aponta para nenhum local na memória. E no final da linha, você pode simplesmente verificar, ei, não está apontando para nada e executar seu código aqui. Por que não funcionou corretamente se você acabou de fazer isso? Fazer essa verificação aqui não funcionará se você não disser. Tudo bem, então é basicamente assim que o nulo funciona com ponteiros. Isso só permite que você diga explicitamente que seu ponteiro não está apontando para nada no momento e permite que você verifique se ele está apontando para alguma coisa antes de fazer algo com ele. E se você quisesse, você sempre poderia fazer algo assim. Três, digamos o contrário, e depois imprimir um ponteiro, é apontar para qualquer coisa apenas para avisá-lo quando seu código é executado que odiava minha declaração if nunca disparou. Porque quando seu código fica muito maior, você pode ter uma declaração if como essa. E pode ser difícil perceber que, ei, esse código não funcionou se você não se avisar . Então aí está. É assim que a natureza trabalha com ponteiros e a importância de usar nulo com ponteiros. E como sempre, obrigado por assistir, e nos vemos na próxima. 78. Capítulo 14 (ponteiros): ponteiros e funções: Neste vídeo, falaremos um pouco sobre ponteiros com funções. Então, assim como poderíamos com referências, ter um tipo de retorno, ser uma referência e uma batida perimetral que eu referenciei. Podemos fazer o mesmo com ponteiros. E porque já falamos sobre isso com referências. E como dicas, referências e muitas maneiras funcionam de forma muito semelhante, vou colocar tudo isso em um vídeo em vez de colocá-lo em dois vídeos separados. Então, vamos entrar nisso. Então, aqui em main, vamos criar uma função que tenha um ponteiro para um parâmetro. Então, o que vamos fazer aqui, diz Lloyd, mudar o valor assim. E então, entre parênteses, diremos int asterisco e chamaremos isso de x assim. E então, entre colchetes aqui, diremos que o asterisco x é igual a dez. E então, aqui em cima, vamos criar uma variável inteira, digamos que x é igual a cinco, assim. E então aqui embaixo, vamos em frente e chamaremos nossos métodos de dizer valor de mudança, e então vamos inserir x assim. E precisamos garantir que o grau seja um protótipo aqui. Então, vamos fazer isso aqui em cima. E antes da nossa chamada de função, vamos imprimir x e criar uma linha como essa. Agora, observe que temos esse erro, e isso ocorre porque int é incompatível com o parâmetro do tipo int pointer. E se isso fosse uma referência, como essa, eu trabalhei muito bem porque, bem, enviaríamos X e aqui, isso criaria uma referência à nossa variável ser x. E podemos nomeá-la como quiser. E eu vou seguir em frente e realmente renomear esse número aqui, assim. Ok, então temos int num, imprimimos e depois enviamos como argumento. E se isso fosse uma referência, isso teria funcionado muito bem. Teríamos criado uma referência sobre quem ovos e mudado x e meio que a tiramos. Aqui embaixo. Acabei de imprimir novamente. E agora, que mudança para dez. E também temos que trocá-lo aqui em nosso protótipo por apenas um momento e ver se o executamos, ele funcionaria muito bem. No entanto, um ponteiro não armazena o valor diretamente e armazena o endereço. Então, se formos em frente e mudarmos isso de volta para um ponteiro agora, ainda podemos fazer a mesma coisa, exceto que temos que enviar o endereço da variável. Então, vamos colocar nosso símbolo de e comercial aqui. E aqui embaixo, não podemos simplesmente dizer que x é igual a dez porque não queremos mudar o endereço do ponteiro. E você pode ver que isso nos dá um erro, na verdade, mas não podemos mudar o. Então, se prosseguirmos e desreferenciarmos isso, funcionaria muito bem. Agora, criamos um número inteiro chamado num, que não é igual a cinco. Em seguida, imprimimos num, que imprimirá apenas cinco, obviamente. Em seguida, enviamos o endereço de num para nosso parâmetro aqui. Então, agora temos um ponteiro que aponta para o endereço de num e, em seguida, desreferenciamos um ponteiro. Então, estamos dizendo que o valor mantido no endereço de num, queremos mudar para dez. E então isso também mudará de número para dez. E se executarmos nosso código aqui, você pode ver que é isso que acontece. Agora. E se tivéssemos criado um ponteiro primeiro? Então, se definirmos um asterisco, chamaremos esse ponto assim, definiremos como igual ao endereço de num e depois o enviaremos. E agora, se executarmos um código, isso é exatamente a mesma coisa. A única diferença é que acabamos de enviar nosso ponteiro. Então, basicamente, tínhamos um ponteiro que apontava exatamente o mesmo endereço e obtivemos o valor que estava lá depois o alteramos para dez. Então isso também funcionou. E, por fim, vamos seguir em frente e ter um ponteiro como tipo de retorno. Então, vamos desinicializar nosso ponteiro aqui e definir isso como nulo. Lembre-se de que, se você não for inicializá-lo originalmente, deverá defini-lo como nulo. Então, faremos isso. Então, aqui embaixo, vamos enviar o endereço de Num. Então, vamos dizer n, entorpecido, assim. E vamos mudá-lo de vazio para um tipo de ponteiro como esse. E precisamos fazer o mesmo aqui. Então aqui embaixo, o que vamos fazer é devolver x, então agora temos uma renda igual a cinco. Em seguida, imprimimos. Em seguida, criamos um ponteiro chamado ponto que atualmente não aponta para nada. E dissemos explicitamente que , definindo-o igual a não, então executamos nosso método aqui chamado de método deles, que pegou o endereço de num, colocou em um ponteiro que chamamos de x, e então retornamos isso ponteiro, que se você se lembrar de um ponto para apenas contém um endereço, e retornamos o endereço e um ponteiro inteiro, que será enviado de volta aqui. Então, agora temos um ponteiro int que contém o endereço de num porque foi isso que enviamos. Mas queremos ir em frente e armazenar isso em algum lugar. Lembre-se de que, sempre que estiver transformando algo, você deve armazená-lo em algo. Caso contrário, é. Então, aqui, o que vamos dizer é 0 é igual a isso, e isso funcionará muito bem. Agora, o que podemos fazer depois de um método chamado é, digamos, que queremos desreferenciar. Lembre-se de que vamos colocar um ponteiro de asterisco e defini-lo como igual a dez, mais ou menos como fizemos antes. Então, agora estamos dizendo que queremos pegar o endereço de num, basicamente desreferenciá-lo. Eles obtêm o valor real de nenhum, que atualmente é cinco, e o definem igual a isso, então vamos imprimir dez aqui embaixo. E vamos dar uma olhada nisso rapidamente. Então aí está. O top 510 e como queremos que seja? Poderíamos ter colocado essa chamada de método aqui nos livrado dela aqui. E isso também teria funcionado bem, já que isso está retornando um endereço para nós e precisamos defini-lo como um endereço. Isso funciona muito bem e com elegância. Então aí está. Essencialmente, funciona da mesma forma que o tipo de referência que, exceto que, com algumas ressalvas, pôr do sol contém um endereço em vez do valor, como nosso tipo de referência. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 79. Capítulo 14 (ponteiros): ponteiros e matrizes: Neste vídeo, falaremos sobre ponteiros e matrizes, bem como sobre algumas das interessantes semelhanças e interações entre eles. Então, vamos começar. Primeiro, vamos criar uma matriz de números inteiros. Então, vamos dizer int, minha matriz, então eu vou abrir e fechar colchetes foi colocado em um número como três aqui. E eu quero definir isso igual a três números diferentes. Vamos em frente e digamos 1025. E então, aqui embaixo, vamos criar um ponteiro. Então, vamos dizer int asterisco, e eu direi PTR, abreviação de ponteiro. E então vamos dizer que é igual à minha matriz, assim mesmo. Então eu estou pensando em mostrar que esse valor aqui só precisa ser um continente e você não precisa colocar um número aqui diretamente. Então, se dissermos vezes e depois chamarmos esse tamanho de matriz, por exemplo, defina isso como três. Na verdade, podemos colocar o tamanho da matriz aqui mesmo em nosso tamanho de matriz, se você quiser. E aqui embaixo, o que vamos fazer é criar um for-loops básico, pois I é igual a 0, I menor que o tamanho da matriz I mais plus. E então, dentro do nosso for-loop, o que vamos fazer é imprimir algumas coisas diferentes. Vamos imprimir os endereços dessas variáveis aqui, bem como os valores usando nosso ponteiro. Então, vamos dar uma olhada em algumas maneiras de fazer isso. O primeiro seria o seguinte. Podemos dizer algo como C. E, entre aspas aqui, podemos dizer endereçar minha matriz no painel, colchete aberto. E depois disso, podemos desenhar N. E depois disso, criaremos outro conjunto de aspas seguido por um colchete fechado para dizer igual a mais assim. Então, abaixo, diremos CL, PTR sendo o nome do nosso álibi em mente. Então, agora vamos copiar e colar isso abaixo também. exército muda este para um valor assim e deixa o resto , exceto ele aqui embaixo. Estou dizendo C out pointer. Vamos desreferenciar um ponteiro aqui, e isso imprimirá o valor. Mas agora, como vamos realmente repetir e imprimir um valor após o outro? Bem, o interessante é que essa linha aqui está basicamente dizendo que fomos para um endereço de sinal da minha matriz no índice 0 do GTR. Então, essencialmente, isso é como dizer que o ponteiro igual ao meu índice de matriz 0 com um sinal comercial aqui. E isso e isso são essencialmente equivalentes. A razão pela qual isso atribui o endereço de nossa matriz no índice 0, q pointer é porque o nome da nossa matriz aqui realmente contém o endereço do primeiro elemento da matriz. E isso funciona como um ponteiro constante, o que significa que o endereço armazenado no nome da nossa matriz não pode ser alterado. E, curiosamente, os ponteiros realmente têm alguns operadores que podemos usar neste caso. E eu vou te mostrar um aqui embaixo. Podemos dizer pointer plus, plus. E à medida que isso sobe pelos endereços, se você quiser, ele vai subir ao longo desses elementos. E se você se lembra de quando falamos pela primeira vez sobre matrizes, eu disse que esses valores foram armazenados em ordem sequencial. E então, essencialmente, podemos simplesmente mover nosso ponteiro para cima em ordem sequencial para subir ao longo desses valores. Como nosso ponteiro está começando no índice 0 aqui e a cada execução de nosso código, você pode ver que dissemos o endereço da minha matriz no índice 0, que só foi indicado por esse valor I que estávamos aumentando é igual a ponteiro. E aí está nosso endereço. E então definimos um valor da minha matriz no índice 0 igual a dez. E isso é porque desreferenciamos esse endereço aqui. E então aumentamos nosso ponteiro em um aqui. E isso o moveu para cima em um elemento na matriz, essencialmente. E podemos imprimir o próximo endereço e o valor em todo o processo. Agora, vamos dar uma olhada em outra maneira, porque eu fiz isso. Então, vamos em frente e remover esse ponteiro mais, mais. E então, na verdade, logo após a palavra ponteiro C Plus Plus nos permite usar a mesma sintaxe que usaríamos para uma matriz quando nosso ponteiro é igual a uma matriz como essa. Então, podemos simplesmente ter colchetes abertos e fechados e colocá-los ali e fazer o mesmo aqui embaixo. E isso realmente nos dará o mesmo efeito, essencialmente. Mas em vez do asterisco aqui, vamos colocar o símbolo e comercial assim e executar nosso código. E como você pode ver, isso realmente funciona como uma variável agora, então é o oposto. Então, se quisermos corrigir isso, você pode simplesmente mover nosso e comercial até aqui. E agora, como se fosse uma matriz, colocaremos o símbolo e comercial aqui para obter o endereço da variável. E nós a usaríamos normalmente para obter a variável em si. Então, se executarmos um código, você pode ver que ele funciona exatamente como antes. Vamos seguir em frente e dar uma olhada em mais uma maneira. Poderíamos trabalhar conosco, e essa não é a última maneira de trabalhar com ponteiros e matrizes. É apenas o último que vamos mostrar aqui e na maioria dos tribunais, então, ao mostrar aqui e na maioria dos tribunais, então, selecionar criando um ponteiro aqui e definindo-o igual à minha matriz, então vamos realmente tornar isso um matriz de ponteiros. Eu coloco colchetes assim. E então vamos simplesmente colocar um redimensionamento ali mesmo, assim. Então aqui embaixo, o que vamos fazer é deixar isso como está. Vamos cortar esse código pois podemos usá-lo mais tarde aqui em apenas um momento. E então, dentro daqui, vamos dizer ponteiro e meu índice de matriz I. Então, agora, nossa matriz de ponteiros que não está inicializada atualmente receberá os endereços desses variáveis. Ok? E então aqui embaixo, vamos criar um loop, outro for. Mas parece o mesmo que o acima. I é igual a 0. Eu menos do que o tamanho I plus, plus. E o bom de dizer o tamanho da matriz aqui e usá-lo para o tamanho real da matriz é que isso é muito legível e fica muito claro quando estamos parando nosso loop e quantas vezes estamos executando através dele, uma vez por elemento em nossa matriz. E então aqui embaixo, vamos colar o que tínhamos antes, exceto que removeremos esse e colocaremos nosso asterisco de volta na parte inferior aqui e executaremos nosso código. E agora funciona da mesma forma que funcionava antes. Então, o que fizemos foi criar um número inteiro constante chamado tamanho da matriz e defini-lo como igual a três. Em seguida, criamos uma matriz inteira e a definimos como igual ao tamanho do tamanho da matriz e atribuímos três valores. Em seguida, criamos uma matriz de ponteiros inteiros e não a inicializamos. E então criamos um loop básico de quatro que seria executado uma vez por elemento em nossa matriz. E definimos aqui cada um dos endereços desses ponteiros igual ao endereço dos valores em nossa matriz. Em seguida, criamos outro for-loop que foi executado a mesma quantidade de vezes que aquele aqui em cima, e simplesmente imprimimos nossos endereços normalmente, assim como estávamos imprimindo o valor de uma matriz, em seguida, a referência a isso mais uma vez, e apenas para recuperar, ou resumimos nossos exemplos anteriores também. Deixe-me ir em frente e voltar aqui. Então, nós apenas criamos uma matriz e, em seguida, criamos um ponteiro e definimos o endereço nela igual a esse endereço aqui. Essencialmente, isso ocorre porque o nome da nossa matriz aqui realmente contém o endereço do primeiro elemento. E foi o mesmo que se disséssemos isso aqui. Ok, então se eu executei meu código assim, isso funcionará muito bem. Agora, C plus plus nos permitirá realmente usar a mesma sintaxe. Imprimiríamos os elementos em nossa matriz com nosso ponteiro aqui. Ok? E então, se voltarmos ao nosso exemplo original, onde tínhamos isso aqui, mais uma vez, a mesma coisa quando um código aqui para a lixeira aqui. E tudo funcionará da mesma forma, exceto que desta vez, em vez de usar a sintaxe da matriz, simplesmente aumentamos a posição do nosso ponteiro e ele sobe um elemento por vez. Agora, algo que poderíamos ter feito para fazer isso ao contrário , como o seguinte. Podemos atribuir o ponteiro mais igual a para movê-lo daqui para cá, porque ele foi movido para cima em dois lugares. Então, em vez de estar em dez e agora apontar para o 50, que é minha matriz no índice dois. Então poderíamos ter dito ponteiro menos, menos aqui e começado nosso índice em três, e então dito: Bem, eu é maior que 0 menos menos menos, e executado nosso código. E agora teria ido na ordem inversa. E, na verdade, nossos indutores estão desligados por apenas um. Então, podemos corrigir isso alterando i2 para start e dizendo: Bem, I é maior do que menos um. E Marina de novo, e lá vamos nós. Então, o endereço da minha matriz no índice dois, porque foi aí que começamos agora, é o seguinte, e o valor é 50, então obtemos o endereço do índice um e assim por diante. Então aí está. Há algumas interações interessantes entre ponteiros e matrizes. Se você está curioso sobre o nome da nossa matriz contendo o endereço do primeiro elemento e não apenas o valor. Se você se lembra do vídeo em que enviamos uma matriz como argumento para um perímetro que levou e foi passado por referência. E isso porque ele contém o endereço, não o valor. De qualquer forma, isso é tudo para este vídeo, eu sei que era muita informação. Portanto, se você não entendeu totalmente, fique à vontade para assistir novamente ou procurar mais informações sobre o assunto. Caso contrário, não se preocupe, não vamos realmente lidar conosco durante o resto do curso. De qualquer forma, isso é tudo para o vídeo. Obrigado por assistir, e nos vemos na próxima. 80. Capítulo 14 (ponteiros): ponteiros vs referências: Neste vídeo, falaremos sobre algumas das diferenças entre ponteiros e referências para que você saiba quando usar, quais. Então, vamos começar. Primeiramente, as referências são usadas como aliases para variáveis existentes, enquanto os ponteiros são usados para armazenar endereços de variáveis. Além disso, as referências não podem ter um valor nulo, mas os ponteiros podem, e os ponteiros podem ser alterados posteriormente. Além disso, em uma nota menor, como os ponteiros contêm endereços, eles precisam ser referenciados com o símbolo de asterisco. Já as referências podem ser vistas automaticamente como uma constante. Por padrão. Vamos apenas uma maneira de ver uma referência como um ponteiro que não pode ser alterado. Essa, por padrão, é a referência. E então você tem. Aqui estão algumas diferenças básicas entre os dois. E há ainda muito mais que você pode fazer com dicas que nem mencionamos. Por exemplo, você pode ter ponteiros para ponteiros. Há vários outros contêineres que não abordamos neste curso você precisa usar ponteiros para trabalhar com os quais você precisa usar ponteiros para trabalhar e aritmética de ponteiros. Você também pode usar ponteiros ao fazer coisas com alocação dinâmica de memória também. E por causa disso, os ponteiros são muito mais versáteis e permitem que você tenha um código muito mais complexo para fazer várias coisas diferentes em comparação com as referências. Então, em vez de fornecer todos os casos de uso de cada um, vou apenas dizer quando você geralmente deve usar uma referência e , como nota geral, você usará ponteiros para todo o resto. Então, quando você deve usar referências? Bem, de um modo geral, você vai querer usar referências ao trabalhar com parâmetros de função e tipos de retorno, como vimos anteriormente. Agora, obviamente, isso pode variar dependendo do tipo de dados com o qual você está trabalhando, mas isso é apenas uma observação geral. Agora, outro bom momento para usá-los é quando você deseja trabalhar com os elementos originais em um para cada loop. E isso pode mudar dependendo do tipo de dados e do contêiner com os quais você estava trabalhando. Então, essas são apenas algumas regras gerais. Como eu disse, isso definitivamente pode mudar dependendo da sua situação. E então você só usaria ponteiros para outras coisas. E nós só tocamos na superfície dos ponteiros e há muito mais que você pode fazer com eles. Então, se você estiver interessado em tudo isso, definitivamente vá em frente e faça sua pesquisa sobre isso. De qualquer forma, isso é tudo para este vídeo. Eu só queria abordar algumas das diferenças entre ponteiros e referências, bem como dar uma ideia geral de quando usar referências. que, por proxy, você saiba quando usar ponteiros em vez disso, além de tocar em um. Outra maneira de ver as referências em comparação com os ponteiros é essa aqui. De qualquer forma, espero que você tenha gostado do vídeo. Obrigado por assistir, e nos vemos na próxima. 81. Capítulo 15 (aulas): Introdução ao OOP: Neste vídeo, falaremos sobre o que exatamente é a programação orientada a objetos, também conhecida como o p. Agora, a programação orientada a objetos trata de criar objetos que contenham ambos dados e funções que representam objetos do mundo real. Esse tipo de programação tem várias vantagens sobre a programação procedural, que consiste principalmente em escrever funções que executam operações nos dados, em vez de criar objetos ou classes. E não vamos nos aprofundar muito nos detalhes da programação processual ou funcional. Mas, bem rápido, vamos falar sobre algumas das vantagens da programação orientada a objetos. Bem, em primeiro lugar, a Programação Orientada a Objetos é mais rápida e fácil de executar. Ele fornece uma estrutura clara para seus programas e evita que você precise se repetir, facilitando a manutenção, modificação e depuração do código. E a última vantagem que mencionaremos aqui é que a programação orientada a objetos permite criar programação orientada a objetos permite criar aplicativos reutilizáveis feitos com menos código e desenvolvidos. Pastor, agora, até agora, você provavelmente já me ouviu referir a objetos e classes como a mesma coisa. E muitas vezes você ouvirá pessoas usarem a palavra objeto e classes de forma intercambiável, mas, com toda a tecnicidade, elas são coisas diferentes. Então, lembre-se de como eu disse que colapsos representam objetos do mundo real usando funções e dados. Bem, vamos falar sobre as diferenças entre classes e objetos e o que uma classe seria em relação a um objeto do mundo real como exemplo, e quais seriam os objetos dessa classe. E você verá o que quero dizer aqui em um segundo. Então, por exemplo, vamos usar frutas, algumas frutas doces usadas com nosso exemplo de enum em um vídeo anterior. Assim, podemos criar uma classe chamada Pro. E essa não é a sintaxe de uma classe. É assim que estou escrevendo isso aqui. Isso teria diferentes conjuntos de dados e funções. Então, por exemplo, você pode ter dados para representar a doçura, tamanho e talvez a cor da semente. Ele pode ter funções para o crescimento ou a vida útil da fruta , como exemplo aqui. E então teríamos objetos de classe de frutas ou instâncias dela que herdam essas variáveis e funções , mas têm sua própria instância. Então, alguns exemplos de objetos de nossa classe de frutas que podemos ter seriam coisas como uma maçã ou banana, laranja, uvas, etc. Então, essencialmente, nossa classe de frutas seria como o modelo para tudo o que herda dela. Ou se a for uma instância disso. Então, por exemplo, a Apple teria um nível de doçura de tamanho, uma contagem de assentos e uma vida útil. Então, o que nossa banana e nossa laranja, nossas uvas, etc. Então, isso meio que define o que é uma fruta e são objetos de nossa classe, são exemplos do modelo definido em nossa classe. Outra coisa a mencionar aqui, embora tenhamos esse exemplo escrito como uma maçã seria uma fruta, e uma banana seria uma fruta, etc. Mas uma maçã não é necessariamente uma banana. A banana não é necessariamente uma laranja, pois cada uma delas seria diferente por si só, mas todas seriam uma fruta nesse caso. De qualquer forma, espero que tudo faça sentido. Eu sei que era uma espécie de informação para absorver de uma só vez. Mas se não, vamos criar um trabalho com classes e dividi-las peça por peça, assim como fizemos com funções. Portanto, não se preocupe, fique atento. Obrigado por assistir. E te vejo na próxima. 82. Capítulo 15 (aulas): criação de um curso: Neste vídeo, vamos criar nossa primeira aula. Então, se você se lembrar, uma classe é um tipo de dados definido pelo usuário que tem dados e funções, chamados de membros. E esses membros criam um plano para objetos ou instâncias de nossa classe. Então, no vídeo anterior, falamos sobre frutas e depois nomes de frutas diferentes para os objetos. Mas outro exemplo seria se tivéssemos uma classe chamada carros que tivesse variáveis como marca, modelo e ano. E então podemos ter funções para avançar, retroceder, entrar em ponto morto, etc. E então os objetos de nossa classe são os exemplos de que seriam veículos diferentes. Cada um deles teria seu próprio modelo e ano, e também teria suas próprias instâncias das funções para viajar. Então, espero que isso tenha feito sentido. Se não, vamos criar um exemplo de aula aqui em apenas um momento. Mas antes de fazermos isso, tenho algumas enumerações aqui, outro tipo definido pelo usuário com o qual trabalhamos. E a razão pela qual eu os tenho aqui é que mostra as semelhanças a sintaxe para criar estou trabalhando com uma classe, que abordaremos aqui em apenas um momento. E só para mostrar algumas coisas extras com enums, agora que você tem um pouco mais de conhecimento de programação. Então, se você se lembra, acabamos de dizer o suficiente, cara com o nome de nosso enumerado. E então, entre colchetes, nós realmente tínhamos os diferentes valores de enum. E então, no passado, criamos variáveis diferentes do nosso tipo de enum dizendo nosso tipo de dados, que era nosso enum, seguido pelo nome da variável e, em seguida, definindo-o igual a um dos nossos possíveis valores lá. Mas algumas coisas que eu não mostrei as seguintes, em vez de criar uma variável separada em uma nova linha aqui embaixo, como essa, poderíamos simplesmente colocá-la após os colchetes, mas antes do ponto e vírgula. Assim, você pode criar quantas variáveis quiser dessa forma, basta separá-las com vírgulas. Então, neste exemplo aqui, eu criei uma variável extra chamada flavour one e depois uma chamada flavor também. E eu inicializo o Flavor 1 aqui embaixo. E eu simplesmente tenho a declaração de sabor aqui. E este acima, eu fiz algo muito parecido, exceto que eu deixei de fora o nome desta, que significa que eu não posso criar uma variável mais tarde assim, já que eu não tenho como referenciá-la e nosso código realmente funcionará bem assim. Então, para criar variáveis dessa, tive que colocá-la depois, como fiz aqui embaixo. Você também pode inicializá-los aqui, assim. E eu poderia ter feito o mesmo aqui embaixo. Caso contrário, eu também posso inicializá-lo aqui embaixo, como fiz com este. De qualquer forma, eu só queria te mostrar isso rápido. Basicamente, a única diferença é que você poderia remover completamente o nome do seu ENM, mas lembre-se de que você não seria capaz de referenciá-lo. E que você pode ter as variáveis declaradas e inicializadas na mesma linha, basta colocá-las após os colchetes e antes do ponto e vírgula. De qualquer forma, vamos em frente e remover isso. E então vamos criar uma classe ou simplesmente criada de uma forma muito semelhante. Portanto, a sintaxe de uma classe é a seguinte. Primeiro, você vai dizer classe, seguido pelo nome da turma. E então, entre colchetes, você terá seu código real, ou devo dizer, os membros dessa classe. E depois dos colchetes encaracolados, você pode ter seus objetos, se quiser, separados por vírgulas. Então, por fim, você vai fechar isso com um ponto e vírgula. Então, aqui embaixo, vamos criar uma classe básica. E o que vamos fazer é criar uma classe para animais. Então, diremos animais de classe como esses na convenção de nomenclatura normal para nossa classe como CamelCase, começando com uma letra maiúscula, abrindo e fechando colchetes. Assim, por dentro, teremos nossos membros. Portanto, você pode ter uma variável inteira chamada idade. Então, abaixo disso, teremos uma variável chamada altura, e vamos deixá-la assim por enquanto. Então aí está. Agora criamos uma classe muito básica chamada animais. Temos dois membros de dados diferentes dentro dele. Portanto, suas variáveis que estão dentro de uma classe e suas funções dentro da classe são chamadas de membros de sua classe. E algumas pessoas gostam de prefixar todos os seus membros com um sublinhado como esse. Então, diga que eles são membros da classe e não apenas variáveis regulares. Então, vamos em frente e realmente fazer isso. E então, como eu disse, ele também declara objetos diferentes aqui, depois de um colchete e antes do nosso ponto e vírgula, se quisermos. Então, podemos ter um objeto cachorro e um objeto gato, por exemplo. E se executarmos um código aqui, e você puder ver que ele funciona bem. Agora, obviamente eu não fiz nada, mas eu só queria mostrar que não tivemos nenhum erro. E, no momento, essa classe só existe dentro da nossa função principal. E depois desse ponto aqui, no entanto, podemos realmente cortar isso dessa forma e colocá-lo fora do nosso método para que agora seu escopo seja global em vez de local aqui. De qualquer forma, isso é tudo para este vídeo. Mas antes de passar para a próxima, o que eu quero que vocês comecem a fazer é salvar seu código. Porque na próxima série de vídeos, vamos aumentar lentamente nossa classe para torná-la cada vez mais complexa e ver diferentes exemplos de coisas que podemos fazer com ela. Então, como eu disse, certifique-se de salvar seu código para que possamos usá-lo no próximo vídeo. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 83. Capítulo 15 (aulas): objetos de curso: Neste vídeo, criaremos instâncias ou objetos da nossa classe. E antes de fazermos isso, vamos realmente remover essas duas declarações de objetos, só para que possamos ver como fazer isso do zero. Então, vamos remover esses objetos para cães e gatos. E, na verdade , vamos criar dois objetos ou instâncias diferentes do nosso vidro aqui embaixo. Portanto, lembre-se de que objetos são instâncias de uma classe ou sintaxe de objeto. Vamos dizer o nome da nossa classe, seguido pelo nome do objeto, esse nome de animal de estimação lá. E por último, um ponto e vírgula. Então, vamos seguir em frente e criar duas instâncias da nossa classe. E isso é tudo que farei neste vídeo. Vamos dizer que animais estão sendo o nome da nossa classe. E então diremos cachorro, por exemplo. E continue com um ponto e vírgula. E então também criaremos outra instância ou objeto, se você quiser, da nossa classe chamada animais felinos. E vamos colocar um ponto e vírgula no final disso. E então vamos fazer mais uma coisa antes de finalizar este vídeo. Então aqui em cima, em vez de oi, vamos dar um nome a cada animal. Então, vou dizer nome da string. E então, só para mostrar algo rápido, tentamos criar uma instância de cada uma dessas variáveis para nossos objetos aqui. E podemos fazer isso fazendo o seguinte, dizendo o nome do nosso objeto, cachorro, nesse caso, seguido pelo nome da variável que queremos acessar. Então, você diria o nome do ponto do cachorro e tentaria defini-lo como igual a uma string aqui, você percebe que receberemos um erro e isso ocorre porque o nome do animal está acessível. E falaremos sobre o porquê no próximo vídeo. Então vá em frente e diga que você agradece por assistir, e nos vemos na próxima. 84. 83: Neste vídeo, falaremos sobre algo chamado especificadores de acesso ou que vem de outro idioma. Você também pode ter ouvido isso ser chamado de modificadores de acesso. Agora, existem três tipos diferentes, quatro números. Primeiramente, você tem membros públicos e os membros públicos podem ser acessados de fora da classe. Então você tem membros privados e privados que não podem ser vistos ou acessados de fora da classe. E, por fim, você protegeu, que só pode ser acessado e visualizado por classes herdadas. E entraremos em herança em outro vídeo. Mas a única coisa que eu quero que você note aqui é que as classes, por padrão, têm membros privados. Então, se quisermos acessar esses membros, como nosso nome de string aqui fora da classe, precisamos torná-lo acessível alterando isso de uma variável de membro privado para um membro público e, ou um variável. E lembre-se disso porque eles fazem parte da classe, eles são chamados de membros. E vou colocar um sublinhado antes do nosso nome de string aqui, apenas para indicar que é um membro. E vamos mudar isso aqui também. E se você se lembrar, se passarmos o mouse sobre isso, diz que o nome do sublinhado dos animais está acessível e isso porque é privado e só pode ser visualizado e acessado de dentro da classe e não de fora. E, a propósito, você também pode ouvir os membros da classe serem chamados de atributos da classe. Agora, como podemos seguir em frente e torná-los públicos? Bem, é bem fácil. Então, tudo o que precisamos fazer é, acima nossos membros aqui, que queremos tornar público, público, cólon, assim mesmo. E aí está. Esses membros agora são públicos. E se olharmos aqui embaixo, você pode ver que agora podemos acessar o membro. Agora, podemos ir em frente e pegar nosso cachorro. Quero dizer, você pode dizer que nome é igual a algo como mancha. E podemos ir em frente e dar a ela o cachorro em H também. Então você pode dizer que a idade do sublinhado do cão é igual a dois, então podemos fazer o mesmo com o nosso gato agora. Então, podemos dizer sublinhado, nome, algo como Garfield. Em seguida, sublinhe que a idade é igual a quatro. Então, agora criamos uma classe chamada animais que tem dois membros ou atributos públicos, se você preferir. Uma delas é uma string chamada nome do sublinhado, sendo chamada de idade do sublinhado. E isso deveria ter sido , na verdade, apenas um número inteiro, não uma string. E então aqui, criamos duas instâncias ou objetos de nossa classe apenas dizendo o nome da nossa classe, Hello com um nome para ela, o objeto e um ponto e vírgula no final. E então cada um deles tem sua própria instância dessas variáveis, ok, então cada um deles tem suas próprias versões. E para acessá-los, basta usar o operador de acesso de membro para o símbolo do período ou o ponto, se você quiser chamá-lo. Dissemos o nome do sublinhado do ponto do cachorro e o definimos como ponto escuro e o ponto escuro h igual a dois. Então, basicamente fizemos a mesma coisa aqui com o gato. De qualquer forma, é para encerrar esse vídeo. Mais uma coisa que quero mencionar é que, para esses outros especificadores de acesso, podemos ajustá-los e explicá-los conforme estão listados aqui. Então, o público ou privado ou poderíamos ter escrito exatamente assim. E isso teria funcionado muito bem. Mas vou seguir em frente e mudar isso de volta para público. Então, no momento, temos alguns membros públicos, mas também poderíamos ter criado membros privados e protegidos, se quiséssemos, simplesmente colando isso antes ou depois. Então, poderíamos ter dito privado, por exemplo , e então ter alguns membros privados abaixo disso e isso teria funcionado muito bem. Então, é assim que se usam especificadores de acesso e a importância deles. E vou seguir em frente e inserir essas variáveis aqui apenas para torná-las um pouco mais legíveis. Agora, como saber qual especificador de acesso usar? Bem, assim como ao trabalhar com escopo variável, ao trabalhar com especificadores de acesso, você só quer tornar as coisas tão disponíveis quanto você precisa. E isso é apenas mais uma vez para evitar qualquer tipo de erro humano. E normalmente você quer, você quer que seus membros sejam públicos assim. E abordaremos isso em um vídeo posterior. Mas, por enquanto, vamos sair do público para que possamos acessar algum tempo aqui. De qualquer forma, isso é tudo para este vídeo. Não se esqueça de guardar o que você tem. E como sempre, obrigado por assistir e nos vemos na próxima. 85. 84: Neste vídeo, falaremos sobre funções de classe ou como criar uma função dentro de uma classe. Então, no nosso caso, vamos criar uma função para falar. É aqui mesmo dentro da nossa classe, vamos dizer algo como vazio. E dirá parênteses abertos e fechados. E então, em um bloco de código aqui, diremos C out. Assim mesmo. E criaremos uma nova linha e colocaremos um ponto e vírgula no final. E o som, na verdade , será uma variável de string que será usada como argumento. Precisamos fazer um perímetro para isso. Então, vamos dizer som de cordas. E isso vai funcionar muito bem. E essa é a forma básica de criar uma função dentro de uma classe. Mas você também pode defini-lo fora de uma classe. E a forma como isso é feito é muito semelhante à criação de um protótipo de função. Então, aqui embaixo, vamos copiar e colar nossa função atual. Agora, para fazer isso, temos que mudar algumas coisas. Primeiro, vamos nos livrar da definição de nossa função aqui dentro da nossa classe. E então colocaremos um ponto e vírgula no final. E então aqui, depois do nosso tipo de retorno, precisamos dizer cólon, cólon de animais. Se você se lembrar, esse é o operador de resolução de escopo. E agora essa definição de método ou definição de função nesta parte da nossa classe de animais, e declaramos que seria uma coisa aqui. Portanto, se você quiser defini-lo externamente, precisará do nome da classe seguido pelo operador de resolução do escopo logo após o tipo de retorno. E então você precisa de uma declaração muito semelhante ao nosso protótipo de função aqui em cima, onde você só tem o tipo de retorno seguido pelo nome, quaisquer parâmetros e um ponto e vírgula no final. Então você tem, agora, vamos usar essa função com nosso cachorro e gato. Então aqui embaixo, abaixo de nossos dois objetos. Vamos prosseguir e incluir nossas chamadas de função. Então, digamos, cachorro, velocidade e entre parênteses dirão arte ou o que você quiser, mas eles realmente não importam. E então Dumbo, que dirá gato, fale entre parênteses. Vamos dizer, ok, e não esqueça o ponto e vírgula no final. E se executarmos nosso código aqui, você pode ver que isso funciona muito bem. E podemos imprimir essas variáveis mesma forma que faríamos com qualquer outra variável. Só precisamos especificar a que estamos nos referindo. Então, podemos dizer algo como c out, cat, name, a nova linha, assim, e isso vai rodar. Então, vamos adicionar algum código aqui para imprimir nossas diferentes variáveis animais. E podemos realmente criar uma função para fazer isso. Então, vamos remover essas chamadas de função também. E então, aqui embaixo, diremos que alguém gosta do animal. E então, entre parênteses, pegaremos um animal. E o nome da nossa classe na verdade é chamado de animais. E talvez para tornar esse som um pouco melhor, vamos renomeá-lo. E você pode passar rapidamente e simplesmente remover o S, ou você pode clicar com o botão direito do mouse e clicar em Renomear aqui no Visual Studio, alterá-lo para animal e pré-visualizar. Então, agora nossa função pega um animal e eu vou chamar esse animal, por exemplo , entre colchetes aqui, vamos imprimir todos os valores dentro daqui. Como estamos trabalhando com um objeto animal, podemos realmente usar todas as funções que poderíamos normalmente Como criamos um objeto animal? Então, podemos dizer algo como CL, nome do animal, espaço do cólon. Olá, sou mãe. Esse nome de sublinhado como esse criará uma nova linha, pode colocar um ponto e vírgula no final. Então, vamos copiar e colar isso uma vez. E diremos CL, idade animal. Em seguida, ele apenas mudará isso para animal, mas sublinhará a idade. E então, por fim, vamos dizer C out. Em seguida, publicaremos o nome do animal. Então, diga o nome do sublinhado animal, assim mesmo. E então, entre aspas aqui, diremos espaço, diz espaço de dois pontos. E vou colocar um ponto e vírgula aqui. E então, abaixo, diremos animal, parênteses abertos e fechados e um ponto e vírgula no final. E então vamos pegar uma série daqui. Então, vamos dizer uma corda aqui para falar. E agora, de volta à nossa função principal, vamos chamar essa função para cada um de nossos animais. Então diga animal vegetal. Entre parênteses, dirá vírgula de cachorro. Em seguida, criaremos nossa string. Então, vamos dizer, bem, vamos colocar um ponto e vírgula apenas no final, e então podemos simplesmente copiar e colar aqueles que fariam mudanças com o gato. E diga: Sim. E então, se voltarmos nossa função animal aqui, vamos em frente e criar algumas linhas apenas para que pareçam um pouco mais limpas para cada vez que chamamos isso de socializar C e linha. Então vamos seguir em frente e fazer isso mais uma vez assim. E lá vamos nós. De qualquer forma, vou diminuir o zoom aqui. Assim, vocês podem examinar o código e copiá-lo, se necessário. E então só precisamos fazer uma última coisa. E isso é criar um protótipo de função para nossa função de animal impresso aqui. Então lembre-se, temos que copiar essa linha aqui, colá-la assim e colocar um ponto e vírgula no final. Agora, se executarmos nosso código, vamos lá. Você disse o nome do animal como mancha. A idade animal é identificar a esposa do filho. Então fizemos a mesma coisa aqui embaixo. De qualquer forma, isso é válido para este vídeo. Não se esqueça de guardar o que você tem. Obrigado por assistir, e nos vemos na próxima. 86. Capítulo 15 (aulas): construtores de classes: Neste vídeo, falaremos sobre construtores. Agora, um construtor é um método especial em C plus plus que é chamado automaticamente quando um objeto, eu vou criar uma classe, é criado. E vamos dar uma olhada no que é isso, um adequado e os casos de uso dele. Agora, só para limpar as coisas aqui em cima, eu poderia continuar e minimizar nosso método aqui só para que eu possa manter tudo na tela. E como já sabemos o que isso faz, não precisamos realmente mexer com isso agora. E apenas amplie aqui. Só sei que eu ainda tenho todo esse código aqui. E eu não estou realmente me livrando disso. E eu também vou criar um espaço vazio aqui entre nossa função principal e nossa classe animal, apenas para manter as coisas separadas. Agora, vamos seguir em frente e criar um construtor. E C mais, além disso, existem três tipos diferentes de construtores. Agora, o primeiro tipo de construtor sobre o qual falaremos é o construtor padrão. E isso parece que sim. Então, quando um construtor for avaliado, você terá o nome da classe. Assim. Em seguida, você terá uma configuração parênteses com perímetros potenciais e, em seguida, seu bloco de código e colchetes curvos, assim. E essa é a aparência do construtor padrão. E sua classe terá automaticamente esse construtor se você não criar seu próprio construtor . Mas depois de criar seu próprio construtor, o construtor padrão não existe mais. Então, caso eu tenha confuso, você está perdido neste momento. Vamos seguir em frente e criar um construtor ao redor. Vou dar uma olhada em como os construtores funcionam. Red Bull ou uma declaração do método speak aqui, vamos seguir em frente e criar nosso construtor. Então, vamos dizer animal sendo o nome da nossa classe, abra e feche parênteses. Em seguida, teremos nosso bloco de código abaixo dele. E dentro daqui, normalmente o que você quer lidar com o construtor inicializar todos os seus membros para que você não os use antes que eles sejam inicializados da maneira que é garantido porque o construtor é chamado automaticamente quando você cria um objeto da sua classe. Então, se isso aqui, dissemos que o nome do sublinhado é igual 0 e, em seguida, a idade do sublinhado é igual a 0, assim. E, na verdade, como nosso nome é uma string, só queremos torná-la uma string vazia. Portanto, isso funcionará muito bem porque não aceita nenhum parâmetro. Isso não afetará nosso código aqui embaixo quando criamos nosso objeto cachorro e gato, por exemplo. Então, se seguirmos em frente e executarmos nosso código aqui, você pode ver que ele funciona exatamente como antes. Mas agora o que vamos fazer é definir nosso construtor aqui fora da nossa classe, como fizemos com o método. Ok, então para fazer isso, vamos fazer é copiar ou construir e colar aqui embaixo, assim. E então só precisa declará-lo no topo. Então, se removermos a definição aqui e colocarmos o que está na linha superior e colocarmos um ponto e vírgula como esse. E então aqui embaixo, temos que fazer a mesma coisa que fizemos aqui. Então, vamos dizer animal, seguido pelo operador de resolução de escopo. Em seguida, dirá animal novamente sendo o nome do construtor e também o nome da nossa classe seguido por nossos parênteses. E, por fim, nossa definição aqui. Então, tudo o que precisamos fazer é basicamente a mesma coisa que fizemos aqui, exceto que não tínhamos um tipo de retorno, então colocamos isso antes do nome do construtor, e isso funcionará muito bem. Então é assim que você pode declarar um construtor dentro ou fora da sua classe, assim como poderíamos com nossa função aqui. Agora, uma coisa que eu quero mencionar é que um construtor precisa ser público. E isso porque, como eu disse, um construtor é um método especial executado quando você cria um objeto da classe. E como criamos nossos objetos de nossa classe fora da classe, o construtor precisa ser público. Então não esqueça isso. Agora, e se quiséssemos adicionar alguns parâmetros ao nosso construtor? Bem, temos algumas opções. Primeiro, podemos adicioná-los a esse construtor aqui, ou podemos sobrecarregá-lo da mesma forma que podemos sobrecarregar funções criando outro construtor com o mesmo nome exato que usa parâmetros diferentes. Mas vamos seguir em frente e mudar o que temos aqui. Então, o que vamos fazer é dizer nome da string vírgula h, assim mesmo. E copiaremos isso para o nosso construtor real abaixo. E então, em vez de apenas dar a eles um valor em branco para começar, vamos seguir em frente e colocar quais são nossos parâmetros aqui. Então, diremos que o nome do sublinhado é igual ao nome e o sublinhado que a idade é igual à idade. Lembre-se de que esses são membros reais da classe. E esses são os parâmetros que nos foram transmitidos. E essa é outra razão pela qual é bom prefixar seus membros com um sublinhado. Deixe você saber que é um membro. Quando você trabalha com isso no futuro, não precisa verificar as coisas. Então, agora, se formos até aqui, você pode ver que temos um erro. E isso porque o único construtor agora para nossa classe de animais requer dois parâmetros. Porque, se você se lembrar, já que criamos um construtor, o padrão que teria essa aparência , não existe mais. E você poderia ter qualquer Cody, um deles aqui. Então, eu poderia dizer que talvez um novo animal tenha sido criado ou algo parecido. E todo esse código seria executado toda vez que criássemos um novo animal e usássemos esses parâmetros para chamar esse construtor especificamente, agora, agora, só temos um, mas se sobrecarregamos isso, então teríamos que ter esses parâmetros para chamá-lo aqui especificamente, como vimos quando sobrecarregamos funções e no passado. Então, agora, se voltarmos aqui, se lermos o que esse erro diz, assim que não houver um construtor padrão para animal, o que significa que agora precisamos de parâmetros e podemos corrigir isso. Como eu disse, sobrecarregando isso e tendo um que não aceita parâmetros e se parece com os aqui. Ou podemos deixar isso e dizer: Ei, agora se você quiser criar um animal, você precisa inserir esses dois valores, e é isso que vamos fazer. Então, aqui embaixo, tudo o que precisamos fazer se o cão tiver dois parênteses e depois precisarmos inserir nossos parâmetros. Então, em vez de dizer “lugar aqui”, vou colocá-lo aqui. Principalmente a vírgula de Minnesota caiu aqui. Vamos colocá-lo aqui mesmo. Então podemos nos livrar completamente disso, já que já fizemos isso aqui, quando ele inicializar, ele dará o nome do cachorro, o nome que inserimos na idade do cachorro, a idade em que introduzido, e isso vai fazer o mesmo com nosso gato. Não, isso não está alterando as variáveis na classe aqui. Isso está mudando sua instância específica dessas variáveis. Então, fazer algo assim no nosso caso aqui é exatamente o mesmo que isso. Então, vamos fazer o mesmo com o gato. Então, vou abrir um parêntese para começar com. E então, se você ver aqui, eu posso realmente clicar nessas setas. E ele dirá: Ei, o animal usa um nome de string h. Então vamos colocar um nome. Vou colocar uma vírgula R e colocar um H. E agora, quando executarmos nosso código, ele será executado exatamente como antes. E que, na verdade, existe nosso segundo tipo de construtor. Então, já falamos sobre o que é um construtor padrão, que é basicamente apenas um construtor vazio que não aceita nenhum parâmetro e não executa nenhum código no construtor que criado aqui como, na verdade, o segundo tipo de construtor, que é chamado de construtor parametrizado. E um construtor parametrizado é basicamente o que parece. Ele tem um construtor que usa parâmetros e, não se esqueça, o objetivo principal de um construtor geralmente é dar aos membros da classe aqui um valor inicial. Então aí está. Então, temos um último tipo de construtor, chame-o de construtor de cópia. O que é um construtor de cópia como função que inicializa um objeto usando outro objeto da mesma classe. Então, vamos dar uma olhada em como isso parece. E não vamos dar uma olhada na versão detalhada disso por baixo do capô. E não vamos criar um nós mesmos, bem como criado por padrão. Isso funciona muito bem na maioria dos casos. Então, como isso funciona? Bem, por exemplo, temos um animal chamado cachorro, em um animal chamado gato. Mas também podemos ter uma instância da nossa classe animal e simplesmente defini-la como igual a outra instância que já existe. E isso basicamente o copiará. E é aí que seu construtor de cópias entra em ação. Então, poderíamos dizer que animal, gato para liberais, rabo de gato e gato agora é uma cópia de gato. E então aqui embaixo, podemos imprimir isso dizendo print animal. Então aqui vamos dizer gato dois e depois vamos dizer sim, assim, ok, e executar nosso código. E aí está. Agora imprimimos o cachorro com o nome de spot H02 e diz manchas, diz o quê? Porque isso é o que eu coloquei aqui do que fez o mesmo Garfield do que fizemos o mesmo com o gato dois. E observe que todos os valores são iguais, mas diz algo um pouco diferente porque enviamos um argumento diferente com nossa função de animal impresso que criamos no passado vídeo. Então aí está. Esses são os três tipos diferentes de construtores. Você tem seu construtor padrão, que está completamente vazio e não exige que você tenha nenhum parâmetro. Você tem um construtor parametrizado, que é um construtor com parâmetros. E então você tem seu construtor de cópia, que, como eu disse, há um criado por padrão. E muitas vezes isso funciona perfeitamente, que basicamente permite que você pegue uma instância de uma classe e crie uma cópia dela. E não se esqueça de que os construtores precisam ser públicos. E isso, muitas vezes, seu principal uso é inicializar os membros da classe. E aqui eu só quero excluir esse gato para animal aqui junto com a função que o acompanha. Não se esqueça de guardar o que você tem. Obrigado por assistir, e nos vemos na próxima. 87. Capítulo 15 (aulas): iniciantes de lista: Neste vídeo, falaremos sobre listas de inicializadores. Mas antes de fazermos isso, vamos remover parte do código aqui que realmente não precisamos para exemplos futuros. Então, primeiro, vamos remover nosso método de impressão animal aqui, que usa um animal como parâmetro. Então, vamos em frente e removeremos isso completamente. Em seguida, também removeremos as chamadas R2 para essa função. E, por fim, ele removerá o protótipo da função. Para. Agora, temos apenas nossas duas instâncias ou objetos animais junto com nossa classe animal, a função de fala e nosso construtor animal. E você também deve ter notado, acabei de adicionar alguns comentários aqui, só meio que lembro a vocês o que é tudo. Portanto, uma lista de inicializadores é o que você deseja usar quando quiser fornecer os dados aos membros da sua classe. Por exemplo, nossas duas variáveis aqui, um valor inicial. Então, no último vídeo, fizemos isso com nosso construtor aqui. E também é assim que você pode ver isso feito em outros idiomas, mas em C plus plus, essa não é a maneira correta de inicializar seus membros. E há vários motivos para isso. Por um lado, certos tipos de membros não podem ser inicializados dessa forma. Além disso, é menos eficiente em termos de desempenho e vários outros motivos. Então, vamos dar uma olhada na maneira correta de fazer isso. Além disso, se vocês se lembrarem, uma forma de criar uma variável é, digamos, int x. E então, em vez de ter um sinal de igual seguido por um valor, você pode simplesmente dizer int x. E depois entre parênteses tem o valor, pode colocar um ponto e vírgula no final. E isso é exatamente a mesma coisa, certo? A razão pela qual eu queria lembrá-lo dessa opção de sintaxe é porque usaremos algo muito semelhante quando inicializarmos os membros e nossa classe aqui usando uma lista de inicializadores. De qualquer forma, vamos dar uma olhada em como criar um. Então, aqui em nosso construtor, tudo o que temos que fazer no final desse parêntese aqui, eu digo dois pontos e, em seguida, sublinhado, nome , por exemplo, porque essa é a variável ou o membro que queremos inicializar. E então, entre parênteses, podemos simplesmente colocar o parâmetro que vamos passar para ele. Então, vamos defini-lo como nome, assim, então qualquer outro membro era separado com uma vírgula, então digamos vírgula sublinhado idade e, em seguida, entre parênteses, igual à idade, permaneça em seu parâmetro aqui, e é basicamente isso. Então, isso aqui fará essencialmente a mesma coisa que fizemos aqui: podemos realmente remover esse código e nosso bloco de código aqui. E isso também limpa as coisas. Então agora, digamos que tivéssemos uma tonelada de membros aqui, em vez de ter que inicializá-los em nosso bloco de código aqui e ter x igual a 0, y é igual a 0, z é igual e assim por diante agora está tudo aqui fora do caminho . E tudo em nosso bloco de código é um código real que queremos executar além da inicialização de nossos membros. Portanto, essa é a maneira correta de inicializar os membros em suas aulas. E você deve fazer isso dessa maneira todas as vezes. Então você não precisa pensar em quando eu faço dessa maneira e quando eu faço de outra maneira? Eu sempre faço dessa maneira. E lembre-se de fazer isso. Tudo o que você vai fazer é depois de seus parênteses e dois pontos seguidos pelo membro. E entre parênteses, você terá o valor ao qual deseja defini-lo igual. E então, para cada membro extra que você deseja inicializar, basta separá-lo por uma vírgula como esta. Agora, isso não precisa ter um perímetro. Poderíamos defini-lo como o que quiséssemos. Mas nesse caso, como tínhamos parâmetros e nosso construtor que foram feitos para inicializar esses valores, seguimos em frente e também usamos nossos nomes de perímetro. Uma última coisa que quero observar é que eles precisam estar exatamente na mesma ordem em que seus membros estão listados em sua classe. Então, porque nosso nome vem primeiro e depois temos nosso número inteiro para idade e precisa ser inicializado. Exatamente a mesma ordem. Isso é extremamente importante, pois são vários erros que podem surgir se você os fizer fora de ordem. Portanto, certifique-se de sempre fazer isso em ordem assim como está aqui, de cima para baixo. E agora, se executarmos nosso código, você pode ver que ele funcionou perfeitamente sem nenhum erro. E, na verdade, em nosso construtor aqui, vamos adicionar algum código para imprimir quando um animal foi criado e especificar as variáveis dentro dele. Então, digamos que CL e animal foram criados. O seguinte. Lembre-se dos atributos como outro nome que você possa ver para os membros ou variáveis da sua classe. E depois linhas como essa. E então aqui embaixo, diremos nome, espaço do cólon. Vamos continuar com isso comigo. E também poderíamos ter colocado o nome do sublinhado aqui. Realmente não vai fazer nenhuma diferença. E criaremos uma nova linha depois disso também. E, abaixo disso, dirá espaço de página como esse. E continuaremos com h. E criaremos uma nova linha depois disso também. E só para mostrar que isso não faz diferença, vamos colocar a idade do sublinhado para este. E se executarmos nosso código aqui, você pode ver que ele funcionou muito bem. E se quisermos limpar isso um pouco, podemos criar algumas linhas em branco extras aqui. E aí está. E eu vou continuar e colocar isso de volta no nosso nome de parâmetro aqui, sendo idade. De qualquer forma, é isso para este vídeo, agora você sabe a maneira correta de inicializar os membros da sua classe, sendo uma lista de inicializadores, que, para resumir, tudo o que você precisa fazer é no final do seu construtor aqui, logo após o parêntese, você colocará dois pontos seguidos por cada membro em ordem e, entre parênteses, você terá o valor para o qual definirá cada um deles s. Você poderia fazer isso para cada construtor que você tem. Porque, se você se lembrar, você pode sobrecarregar construtores, o que significa que podemos ter vários construtores diferentes para nossa classe de animais aqui, todos com o nome de animal, já que um construtor tem o mesmo nome da classe. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 88. Capítulo 15 (aulas): encapsulamento, abstração e propriedades: Neste vídeo, falaremos sobre algumas coisas diferentes. O primeiro é um conceito chamado encapsulamento, que tem um dos quatro princípios principais da programação orientada a objetos. Mas também abordaremos os outros três princípios principais posteriormente neste curso. E então a outra coisa sobre a qual falaremos neste vídeo como getters and setters, o que nos ajudará a colocar o encapsulamento em ação. Então, o que é encapsulamento? encapsulamento em poucas palavras é basicamente o processo de agrupar ou combinar dados e códigos que atuam sobre esses dados juntos em uma única unidade. E essa unidade única seria algo como uma classe. E, muitas vezes, isso leva a esconder seus dados por trás de um código que possa interagir com eles. Vamos dar uma olhada em como implementar isso adequadamente em nossa classe de animais aqui, bem como o caso de uso disso. Assim, você sabe quando e como implementá-lo em seus próprios programas no futuro. Então, vamos entrar nisso. A primeira coisa que vamos fazer aqui é aqui em nossa classe de animais, vamos criar outro número inteiro chamado saúde. Então, logo abaixo da nossa idade inteira, vamos em frente e digamos que M sublinha a saúde. E então, em nosso construtor, vamos adicionar essa variável à nossa lista de inicializadores. Então, depois de sublinhar a idade com a idade e dar ênfase, vamos dizer que a vírgula sublinha a saúde. Então, entre parênteses, vamos definir isso como igual a 100. Ok? Então, isso fará com que um valor padrão de 100 represente 100% ou como você quiser analisá-lo. Para começar, todo animal terá 100% de saúde. E nem vamos tomar isso como um parâmetro. Esse será apenas o padrão para cada animal, já que esse é nosso único construtor. Agora, atualmente, se quisermos mudar a saúde do nosso cão aqui, podemos dizer algo assim. Então, aqui em nossa função principal onde criamos nosso cão, podemos dizer que o ponto do cão sublinha a saúde menos é igual a 50. E isso vai funcionar muito bem. Não há nada que nos impeça de mudar essa variável para o que quisermos que ela seja. E se prosseguirmos e imprimirmos saúde aqui, então diremos C out dark dot health e apenas criaremos uma nova linha. Então, vamos continuar e também imprimir que essa era a saúde do cachorro. Então, diremos que cães iguais a álibi ou saúde de cães e criaremos uma nova linha. Agora, se executarmos um código, você pode ver hey, e animais criados com os seguintes atributos, nome é Spot tem dois anos e a saúde dos cães era F. E vou adicionar algumas linhas em branco extras aqui. Então, vamos dizer a linha M algumas vezes. Só assim, quando executamos nosso código aqui, ele fica um pouco mais legível. Ok? Tudo bem, desculpe, a saúde dos cães é 50. Bem, e se fôssemos em frente e subtraíssemos mais 50 pontos de vida do nosso cão por qualquer motivo? Mas agora, se executarmos nosso código, você pode ver que a saúde dele é 0. Bem, e se fizermos isso mais uma vez? Então, vamos continuar e colá-lo abaixo, assim mesmo. Bem, agora esse valor é menos 50 e talvez não queiramos que isso aconteça com um. E mesmo que nos esquecêssemos de programar em uma semana, não queríamos que nossa saúde ficasse abaixo de 50 se quiséssemos mudar isso mais tarde. Atualmente, teríamos que fazer algo assim. Primeiro, teríamos que descobrir todas as vezes que mudamos a saúde dos cães. E então teríamos que colocar isso como uma declaração if ou algo assim. Você diz que f dog dot sublinha que a saúde é maior ou igual a 50, por exemplo. Então, queremos fazer o seguinte. E então poderíamos colar isso. Ou poderíamos dizer que algo assim a saúde é menor que 0. Então, queremos definir para um cão que a saúde seja igual a 0. Assim. E isso funcionaria, mas isso poderia ser muito irritante. E então, se quiséssemos fazer mais alguma coisa com isso mais tarde, agora temos que encontrar todos esses lugares novamente e mudar todos eles. Mais uma vez. Espero que você possa ver que isso pode se tornar um grande problema com o tempo, especialmente à medida que nosso programa cresce. E podemos ter várias seções do código ou a saúde de um cão seria removida. Ou se estivermos fazendo um jogo aqui, pode haver várias coisas que afetam a saúde de nossos cães ou algo parecido. Então, o que podemos fazer em vez disso? Bem, vamos continuar e deixar isso aqui por enquanto. Então, vamos até nossa aula de animais aqui. Então, o que podemos fazer é ter algumas funções para cada um de nossos membros aqui, para obter e definir os valores, respectivamente. Podemos ter todas as regras para obtê-las e configurá-las dentro dessas funções. E se tornarmos esses membros aqui acessíveis apenas por meio dessas funções , sabemos que em nenhum lugar do nosso código pode haver algo parecido que altere a variável de uma forma que não especificamos. Então, vamos em frente e fazer isso. Então, essas funções são as quais criaremos algo chamado getters e setters. E antes de criá-los, o que vamos fazer é tornar todos os nossos membros aqui privados, que eles só possam ser acessados de dentro das funções para nossos criadores e criadores. Então, abaixo da nossa declaração de construtor aqui, vamos dizer cólon privado. Se você se lembra, esse era nosso especificador de acesso. Agora temos nossos membros públicos e nossos membros privados. E o que vamos fazer é copiar todos os nossos membros daqui de cima. Na verdade, vamos cortá-los e depois colá-los aqui. E agora eles são privados e de carga. Agora, em vez de criar um para cada um deles, diremos que o nome e a idade não podem ser alterados depois o objeto é criado usando esses parâmetros aqui. E então vamos criar um para a saúde. E embora pudéssemos ter criado um para eles, isso nos poupará algum tempo e você terá uma ideia de como isso funciona de qualquer maneira. Então, aqui em cima, vamos criar algumas funções públicas. 1 primeira configuração de saúde e outra para obter ajuda. Então, vamos fazer isso primeiro. Nós diremos: Saia. E então, entre parênteses, não teremos parâmetros seguidos pelo nosso bloco de código, assim. E o que vamos dizer é um sublinhado retornado. E, abaixo, isso criará uma função para definir a saúde. Então, diremos que o vazio define a saúde. E então, entre parênteses aqui, vamos realmente aceitar uma discussão. Então, teremos que criar um parâmetro aqui e diremos int. E então, em nosso bloco de código, dirá que sublinhar saúde é igual. E essa é a sintaxe mais básica para criar um getter e um setter. E se você vem de outra linguagem de programação, você pode reconhecê-las como propriedades. Mas de qualquer forma, esse de cima aqui é o nosso melhor porque isso gera o valor para nós e esse de baixo aqui é o nosso centro. Agora, você pode estar pensando, como isso é melhor do que se nós apenas tornássemos isso público? Agora, atualmente não é. Mas vamos dar uma olhada em como isso pode se tornar mais complexo e ser útil em apenas um momento. Então, agora, se voltarmos à nossa função principal aqui, você pode ver que temos um erro dizendo: Ei, saúde não está acessível e isso porque a tornamos privada. Então, o que teremos que fazer agora é o seguinte. Então, aqui, em vez disso, vamos ter que dizer saúde para cães. Em seguida, colocaremos menos 50 assim. E vamos colar isso três vezes para replicar o que tínhamos antes. E então, aqui mesmo, quando quiséssemos imprimir a saúde do cão, diria que o cachorro não ganha saúde. E isso retornará o valor inteiro para nós. E agora, se executarmos nosso código, você pode ver que ele funcionou muito bem e funciona da mesma forma que antes. E você pode estar pensando consigo mesmo, Bem, como isso é melhor? Bem, vamos dar uma olhada nos benefícios do que acabamos de fazer. Então, se voltarmos para nossa aula de animais aqui, quero te mostrar uma coisa rapidamente. Primeiramente, observe que podemos acessar a saúde sublinhada aqui antes mesmo de mencionarmos o que era a saúde sublinhada. E, a propósito, bem rápido, normalmente quando você tem membros públicos e privados, você vai querer ter os públicos primeiro para que, quando alguém olhe para sua classe, receba todas as informações que eles precisam aqui. Como normalmente, os membros privados realmente não são tão importantes se precisarem deles e devem ser capazes de contar tudo o que está acontecendo a partir daqui. Mas de qualquer forma, voltando ao que eu estava falando, por que podemos acessar isso quando isso está aqui embaixo. E isso porque o que temos aqui atualmente, quando se trata de aulas, não é realmente ler do jeito que parece e como realmente foi lido é como tal. Então, o que vamos fazer para mostrar a você como ele realmente parece para o nosso programa quando ele lê nosso código aqui é : vamos copiar essas duas funções e colá-las abaixo aqui. E vamos simplesmente colá-los na parte inferior agora. E vamos também mover nossa função de fala para lá. Desculpe, construtores da época, assim. E agora vamos trocá-los aqui na nossa classe. Deixe-me diminuir um pouco o zoom para que você possa ver a Grã-Bretanha mudá-los aqui para serem apenas protótipos funcionais. Então, colocaremos um ponto e vírgula e depois removeremos o bloco de código. Cada uma dessas linhas aqui. E então, aqui na parte inferior, vamos adicionar o nome da nossa classe, seguido pelo operador de resolução de escopo, como fizemos com nossa função de fala. Então, deixe-me copiar isso e colar em ambos. assim que nosso código foi realmente lido antes. É por isso que podemos ter a declaração da variável após a definição do nosso método porque ela foi realmente lida. É aí que temos nosso protótipo ou a declaração de nossa função aqui e, em seguida, a definição após o final da classe. Então, isso é algo que não funciona normalmente. Mas quando se trata de aulas, por exemplo, acontece. Então, eu só queria te dar um aviso sobre isso. Ela não estava muito confusa. Por que isso estava funcionando, pois nunca funcionou para nós no passado. Então, agora vamos dar uma olhada em como esses getters e setters são realmente úteis. E também o que fizemos aqui, fazendo com que esse membro da Saúde fosse privado e encapsulado nessas duas funções. Aqui está um excelente exemplo de encapsulamento. Agora, o que podemos fazer em nossa configuração aqui é o seguinte. Então, depois de dizermos sublinhe a saúde. Saúde das pessoas. Também podemos definir um valor mínimo e máximo para isso. Então, agora, se quiséssemos, poderíamos dizer que a saúde do sublinhado F é maior que 100, por exemplo. Em seguida, sublinhe que a saúde é igual a 100. E abaixo disso, poderíamos dizer f, ou poderíamos simplesmente criar outra declaração if aqui. Então, vamos em frente e diremos saúde do sublinhado F é menor que 0. Em seguida, sublinhe que a saúde é igual a 0, assim mesmo. E agora, quando alguma coisa afeta saúde de nossos cães ou qualquer objeto ou instância de nossa classe animal. Então, outro, esse era o cachorro ou o gato, ou outro animal que poderíamos criar a qualquer momento para tentar afetar a saúde, agora temos que passar por essa função de saúde definida e podemos adicionar qualquer código a isso mais tarde sem quebrar nosso código aqui embaixo. Observe que não precisávamos mexer com nada aqui embaixo para adicionar um valor mínimo e um máximo agora, e podemos imprimir algo qualquer momento ou a saúde foi configurada para exibir nosso novo valor de saúde se nós queremos isso ou o que você quiser fazer. E não precisamos mudar nada aqui embaixo. Então, como temos esses getters e setters, nosso código é muito mais dinâmico e não precisamos nos preocupar com todas as vezes que tentamos obter e definir essa variável. Além disso, não precisamos nos preocupar com nada ignorando essas funções e apenas alterando essa variável diretamente porque ela é privada, significa que ela só está disponível em nossa classe, é por isso que nosso A função aqui, que faz parte diretamente da nossa classe, tem acesso a ela, mas algo como essa função principal não teria. Então, depois dessas duas declarações if, vou dizer que a saúde máxima é igual a 100. E aqui embaixo, vou dizer saúde mínima 0, assim, só para nos lembrar do que eles estão fazendo aqui. Agora, se executarmos nosso código, você pode ver que a saúde do cão só diminuirá para 0 agora por causa dessa funcionalidade extra que adicionamos. E observe mais uma vez que não precisávamos mudar nada feito aqui. De qualquer forma, isso é tudo para este vídeo. Mas vamos recapitular o que aprendemos aqui. Por um lado, quando se trata de classes, você pode realmente ter um método, declaração e definição antes qualquer declaração de variável que ele usa , pois é realmente lida assim. No entanto, dito isso, da maneira correta e da maneira que você deve fazer isso daqui em diante para escrever uma definição de método é ter sua declaração dentro da classe e da definição. fora da sala de aula. Por um lado, isso ajuda a bagunçar seu código e, no futuro, se ele separar essa classe e criar seu próprio arquivo de cabeçalho e arquivo CPP ou arquivo C plus. Isso tornará as coisas muito mais fáceis. Portanto, você deve sempre ter suas definições fora da classe. Então, como regra geral, sua classe deve ter apenas declarações e fora da classe devem estar suas definições. Portanto, tenha isso em mente para o futuro. Agora, a outra coisa que aprendemos é como criar um getter e um setter. E embora já soubéssemos como criar funções, agora conhecemos os casos de uso para criar funções específicas, para obter e definir variáveis privadas em nossa classe. E também aprendemos a maneira correta de listar nossos membros públicos versus nossos membros privados sendo públicos no topo e privados abaixo, você pode fazer isso da maneira que quiser. Mas essa é a maneira correta e provavelmente a mais preferida de fazer isso. Porque, como eu disse, quando alguém olha para sua turma respirando no futuro, se você olhar para o código da sua classe, é bom ter todas as coisas públicas no topo aqui porque isso geralmente é tudo o que me importa. E, muitas vezes, os membros atuais são uma espécie de coisa em segundo plano com a qual você pode ou não se importar. Na verdade, dando uma olhada em. Se a minha turma fosse maior, talvez houvesse ainda mais informações privadas a serem examinadas para chegar às coisas que nos interessam, caso elas tenham sido escritas ao contrário. Portanto, como regra geral, você deve ter seus membros públicos no topo. E então aprendemos como usar nosso getter e setter e o caso de uso e alguns dos benefícios de criá-los. Portanto, a principal coisa a considerar é como utilizar o encapsulamento. Então você tem todas as suas declarações dentro de sua classe e suas definições fora dela são escritas fora dela. E então, quando puder, você deve sempre ter seus membros privados para que eles sejam acessados de uma forma que você não queira que eles diminuam a velocidade. Você quer mudar a forma como eles trabalharam com. Você não precisa procurá-lo em todos os lugares seu código e procurar como corrigi-lo, especialmente em caso de erros ou algo parecido. Tudo que você precisa fazer é olhar aqui. Então, o que fizemos aqui foi realmente trabalhar com dois dos quatro pilares principais da programação orientada a objetos. Uma é obstrução e a outra é encapsulamento. E falaremos sobre isso com um pouco mais de detalhes em um vídeo posterior. Mas eles resumem rapidamente o que são e como praticamos ou trabalhamos com os dois. Abstração como método ou processo de ocultar informações indesejadas. Quando pegamos nossos membros como nossas variáveis aqui e os atingimos do mundo exterior ou do resto do nosso código, estávamos praticando abstração. Já o encapsulamento era o processo real de conter as informações. E então esses dois trabalham lado a lado. Então, abstraímos as informações ou ocultamos do mundo exterior ou do resto do nosso código, tornando esses membros aqui privados, por exemplo. E então também encapsulamos essas informações dentro desses métodos ou funções. Então aí está. De qualquer forma, isso é tudo para este vídeo. Não se esqueça de guardar o que você tem. Obrigado por assistir, e nos vemos na próxima. 89. 88: Neste vídeo, falaremos sobre herança. Na verdade, a herança será nosso terceiro pilar da programação orientada a objetos. Agora, eles não estão em uma ordem específica. Acontece que esse é o terceiro qual falamos até agora. Então, o que é herança? Bem, é a capacidade de uma classe de herdar ou derivar propriedades junto com características de outra classe. E vamos criar e dar uma olhada em um exemplo. Então, vamos começar primeiro, vamos em frente e remover algumas coisas do nosso código apenas para limpar as coisas aqui. Então, o que vamos fazer é, além de criar nosso cachorro e gato, não vamos mover as outras linhas de código e nossa função principal desse jeito. E então eu também vou seguir em frente e minimizar nosso setter e getter, já que já sabemos o que eles fazem. Então eu também vou minimizar nosso construtor de animais. Então eu vou mudar nossa função de fala. Então, vou cortar isso bem rápido abaixo do nosso centro aqui. Então eu também vou mudar isso aqui onde temos nossa declaração. Então, vou colocar isso abaixo assim. E lá vamos nós. No momento, isso é muito menos código para analisar. Então, o que vamos fazer é, em vez de ter nossa classe animal e , em seguida, apenas declarar o nome do nosso objeto ou uma instância dele como um cachorro e um gato. Marxismo e criar duas subclasses e/ou classes derivadas. Um para um cachorro, outro para um gato que ambos herdarão da classe animal, mas ambos têm algo único. E o que isso faz por nós é nos permitir obter tudo o que criamos como parte de nossa classe animal e colocá-lo em outra classe sem precisar repetir. Isso não pode apenas levar ao erro humano, mas também torna as coisas confusas quando sabemos algo como: Ei, todo animal terá essa funcionalidade e outra coisa. Então, o que podemos fazer é apenas criar algumas subclasses que são classes derivadas que herdam disso. Então, vamos começar abaixo nossa definição de função aqui, vamos fazer o seguinte. Vamos dizer cão de classe. E então, dentro de nossos colchetes, teremos nosso código para nossa classe de cães, mas não queremos apenas criar uma classe chamada Dog. Queremos que seja herdado de nossa classe animal porque um cachorro é um animal e já criamos uma definição para o que todo animal tem. Tudo bem, então o que vamos fazer para herdar da nossa classe animal é simplesmente após o nome da nossa classe, digamos dois pontos, seguido por um especificador de acesso. Nesse caso, vamos dizer público. E eu vou chegar a isso em apenas um momento. E então o nome da classe que queremos herdar de um animal público, exatamente assim. E lá vamos nós. Agora criamos uma subclasse ou uma classe derivada. Você costuma ouvir essas palavras usadas de forma intercambiável que herdam de nossa classe base ou de nossa superclasse. Portanto, você pode ouvir isso ser chamado de super e sub ou básico e derivado. Agora, por que dissemos público aqui? Bem, deixa eu te contar. Então, se você colocar público antes do nome da classe base, aqui está o que isso vai acontecer. Então, se você se lembrar, você tem três especificadores de acesso diferentes. Público, protegido. E privado. O público disponibiliza todos os membros em todos os lugares. Protegido, torna todos os membros disponíveis somente na classe e em qualquer classe que herde dela. E então, o privado torna todos os membros disponíveis apenas dentro da classe, especificamente. E acontece que, se você disser público aqui, todos os membros do animal que somos públicos são públicos para nossa classe de cães. Tudo o que foi protegido é protegido para nossa classe de cães. E tudo o que era privado é privado para nossa aula de cães. Dito isso, membros privados de uma classe base não podem ser acessados diretamente da classe derivada. Já os membros protegidos podem, ou seja, qualquer coisa que fosse privada, não estar acessível diretamente de nossa classe de cães aqui. Então, o que aconteceria se, em vez de dizer público aqui, mudássemos isso para protegê-lo? Bem, essencialmente, qualquer coisa que herdássemos que fosse pública seria protegida. Qualquer coisa que estivesse protegida permaneceria protegida. E qualquer coisa que fosse privada, que permanecesse privada. Então, agora estamos basicamente cortando qualquer coisa que fosse pública e aumentando a produção. E se disséssemos privados aqui, os membros que herdamos seriam todos privados. No entanto, somente as coisas que eram privadas na classe base não seriam acessíveis diretamente de nossa classe de cães. E tudo o que foi tornado privado colocar em privado aqui agora será privado em nossa classe de cães e como isso nos afeta. Se você estiver um pouco confuso, você pode herdar de uma subclasse como essa. Poderíamos criar uma outra classe herdada do cão, que herda do animal. E você pode fazer isso repetidamente, se quiser. E assim como poderíamos ter outras classes que herdam do cachorro. cão também pode herdar de várias classes. E para fazer isso, tudo o que você precisa fazer é dizer vírgula animal. E continue com a outra classe ou classes que você gostaria de herdar, cada uma separada por uma vírgula. E então você colocaria o especificador de acesso primeiro, mais uma vez para cada um e seguiria com o nome. Então, tudo o que temos aqui, você teria que colocar depois dessa vírgula para todas as outras classes das quais você herdou. Muito simples. Agora, não vamos nos aprofundar em todas as diferentes formas de herança que você pode ver neste curso ou com as quais trabalharemos. Mas saiba que você pode herdar de várias classes. E você pode até herdar de subclasses. E você também pode herdar deles, se quiser, e a lista continua. Mas para nós aqui, o que vamos fazer é dar uma olhada na forma mais básica de herança, ter uma classe que herda de uma única classe base. Então, de qualquer forma, vamos seguir em frente e seguir em frente. Espero que tudo isso tenha feito sentido para você. Então, como dissemos que o público ouve tudo o que era público, teríamos permanecido público em nossa classe de cães porque ela herda todos os membros da nossa classe animal. Qualquer coisa que fosse protegida, que não tínhamos, nada teria permanecido protegida, e qualquer coisa que fosse privada de nossa classe de animais não estará diretamente acessível em nossa classe de cães, porque era privado, acessível apenas para esta aula aqui. E agora o que vamos fazer é criar um construtor para nossa classe de cães. Mas uma coisa que precisamos estar cientes é que sempre que um cachorro é criado e um animal é criado em segundo plano. E se você se lembrar, nós realmente nos livramos do nosso construtor de animais padrão, que não usava nenhum parâmetro, o que significa que atualmente para criar uma instância de um animal, animal aqui precisa de uma string para um e um número inteiro para uma idade. Então, como podemos seguir em frente e implementar isso? Uma coisa que podemos fazer é criar um construtor padrão que não aceite nenhum parâmetro. E embora isso funcione e nos permita criar um cachorro sem precisar inserir nenhum parâmetro para inicializar nosso nome h aqui, não é realmente o que queremos pois isso ignoraria a maneira como nós, estamos inicializando nosso nome e idade, permitindo-nos dar um nome e uma idade aqui embaixo. Então, em vez disso, poderíamos simplesmente herdar todos os construtores de nossa classe animal dizendo “ usando” seguido pelo nome da classe “animal Colin” é nossa resolução de escopo. operador, seguido pela palavra animal novamente e um ponto e vírgula no final. O que isso faria seria herdar todos os construtores. Então, se viéssemos aqui e disséssemos algo como cachorro, meu cachorro pode colocar nossos parênteses. Você pode ver que uma dessas opções, e a propósito, eu apenas percorro essas teclas e as setas para baixo diz que, ei, precisamos ter um nome e uma idade agora, e podemos simplesmente adicionar um nome e uma idade, como fizemos no passado. Isso funcionaria muito bem, mas não vamos fazer isso. E eu vou te mostrar o porquê aqui em um segundo. Então, vamos seguir em frente e nos livrar disso. Mas é assim que você pode herdar todos os construtores da sua classe base. Em vez disso, faremos o seguinte. Vamos criar um novo construtor para cães dizendo cachorro, abra e feche parênteses. E então vamos colocar um ponto e vírgula no final, pois essa será apenas nossa declaração. Mas este aqui usará os mesmos parâmetros que nossa classe de animais usou. Então, vamos dizer nome do cachorro, vírgula, idade int, sem mais nem menos. Em seguida, copiaremos essa linha e colaremos abaixo da nossa classe para realmente implementar a definição. Então, encontraremos nossos colchetes encaracolados abertos e fechados , como sempre. E então, aqui em cima, vamos usar um inicializador de lista para o construtor de nossa classe animal. Então, vamos dizer cólon animal. E então, entre parênteses, inserirá os parâmetros que o construtor de animais requer. Então, vamos usar esse nome como nosso nome de perímetro aqui, e apenas inseri-lo como o nome ou a variável de string para esse construtor aqui em cima, então diremos vírgula h, assim. E então, se você se lembrar, temos que voltar aqui e dizer cachorro sendo o nome da nossa classe, cólon e cólon, para especificar que essa é a definição para este ano. E agora tudo vai funcionar bem. Então, agora, quando criamos um cachorro, este é nosso único construtor para um cachorro e ele pega um nome e uma idade vai fazer agora é inserir esse nome e idade no nome e idade do construtor para nossa classe de animais. E vamos falar sobre tudo isso aqui no final. Portanto, não se preocupe, se você estiver um pouco confuso, basta acompanhar. E então o que vamos fazer dentro do nosso construtor aqui. E vamos até onde temos nosso construtor de animais e simplesmente remover todo o código dentro dele desse jeito. Vamos colá-lo aqui. E então vamos dizer C out. Um cachorro foi criado com os seguintes atributos, nome, nome, idade, idade. E se quiséssemos, poderíamos até dizer algo como sair da saúde. Espaço do cólon 100, já que sabemos que nossa saúde sempre será 100 no início. Então vamos seguir em frente e inserir um ponto e vírgula. E então o que vamos fazer é realmente copiar as n linhas daqui de cima ou cortá-las, devo dizer, colá-las aqui embaixo, certo? Então, agora, sempre que criamos um cachorro, vai dizer que um cachorro foi criado com os seguintes atributos. Nome sendo qualquer nome que coloquemos quando criamos um cachorro, idade sendo qualquer idade que colocamos quando criamos um cachorro, a saúde padrão será 100. E isso porque em nosso construtor de animais, quando aqui é Ram, saúde é automaticamente definida para 100. Então, vamos copiar tudo isso aqui. Então, tudo, desde nossa classe cães até nosso construtor e definição de cães aqui. E cole abaixo. E vamos dizer classe, gato, mude de cães. O nome da string é Cat, String name. E aqui embaixo mudará esses dois, gato também. Eu diria gato no cólon, gato, e podemos deixar o resto como está. E então, aqui embaixo, no bloco de código real, dirá que um gato foi criado com os seguintes atributos. E lá vamos nós. Agora, aqui embaixo, em vez de criar dois animais e chamar um cachorro e quando for um gato, vamos criar um cachorro e um gato. Então, vamos em frente e remover isso. E diremos gato. E vamos chamar isso de meu gato por enquanto. E então, entre parênteses, precisamos de uma string e depois uma para o nome e outra para a idade. Então, chamamos isso de Garfield mais uma vez. E vamos definir a idade para duas vírgulas faltantes assim. Não coloque um ponto e vírgula no final. Agora observe aqui que diz que gato, gato ou o construtor gato está inacessível na linha 81. E isso porque não tornamos nosso construtor público. Lembre-se de que os membros da turma atrasada são privados por padrão. Os construtores precisam ser públicos para que possam trabalhar. Então, vamos apenas dizer público. Então, coloque dois pontos no final, e eu vou em frente e recuarei isso para torná-lo um pouco mais legível e faremos o mesmo com nosso cachorro. Então, aqui em cima, vamos dizer cólon público. Em seguida, vou inserir isso apenas para torná-lo mais legível. E lá vamos nós. Agora, o erro desapareceu. Quem está pronto para ir? Então, abaixo disso, se eu dissesse meu gato ponto, observe que posso obter saúde porque tenho acesso a essa função pública. E eu posso definir a saúde porque também temos acesso a essa função pública. E também podemos falar, que é a função que criamos aqui para imprimir qualquer string que você inserir. Então, vamos mexer um pouco com isso. Então, diremos que meu gato morreu. Defina Saúde. E vamos dizer algo como dez e colocar um ponto e vírgula no final. E isso colocará nossa saúde em dez. Porque se você se lembra de nossa função aqui, SAT Health apenas pega a quantidade de saúde inserida e a define igual a essa. E se quiséssemos, poderíamos ter criado uma função para mudar a saúde por um valor específico. E vamos seguir em frente e fazer isso rápido. Então, aqui em cima, criaremos uma nova função para mudar a saúde. Quer dizer vazio, mudar a saúde. E tomaremos em consideração a saúde. Assim mesmo. Eu não coloco um ponto e vírgula no final. Esta será uma função de troca de ajuda. Ok, vou adicionar um pouco a esses comentários aqui. Então você tem um melhorador de saúde, um setter e um cambista. E se copiarmos essa declaração aqui e depois descermos aqui, e eu vou realmente minimizar nossa função celular por apenas um momento, assim como nossa função de fala. E basicamente entre nossa saúde definida na função R speak. Vou continuar e colar isso. Em seguida, criaremos uma nova função como essa. E dentro daqui, vou copiar todo o código da nossa função set L e colá-lo aqui. E agora vamos dizer que sublinhar saúde é igual a saúde, então podemos deixar o resto. E o que isso nos permitirá fazer é dizer mudar a saúde e , em seguida, inserir um valor positivo ou negativo e adicioná-lo diretamente ao nosso membro de saúde. E observe que temos esse erro, a menos que ainda tenhamos que adicioná-lo aqui , logo antes do nome da nossa função. E isso esclarecerá esse artigo. Em seguida, vamos em frente e minimizaremos esses. E agora, se formos até aqui, podemos dizer algo como meu gato, obter saúde, para obter nosso valor para a saúde. E vamos imprimir isso. Então, diga CL health, então podemos ir em frente e dizer algo como meu gato, mudar a saúde e vamos mudá-la em menos 15. Digamos que nosso gato se machucou ou algo parecido. Em seguida, imprimiremos saúde novamente. Então, vamos dizer C para fora, meu gato morreu. Nenhuma. Vamos também criar um cachorro. Então, aqui embaixo, diremos cachorro. Meu cachorro mudará seu nome para spotty. E tem 23 anos. Vou colocar um ponto e vírgula no final. E vamos também adicionar algumas linhas em branco aqui. Então, vamos dizer em linha e linha assim e executar nosso código. E como você pode ver, na verdade parece um pouco estranho. Então, vamos resolver isso bem rápido. Então, aqui dentro do nosso construtor de cães e animais, precisamos colocar uma linha N depois H e outra após a idade e o gato. Agora, se executarmos nosso código novamente rapidamente, podemos ver que essa parte foi corrigida. Agora só temos essa estranha centena e 85 aqui. E a mudança que tudo o que você precisa fazer é adicionar algum texto aqui. Poderíamos dizer algo como c out. Garfield. A saúde é o espaço do cólon. Adicionaremos outro operador de inserção como esse. E então vamos simplesmente copiar isso. E, por fim, ele criará uma linha em branco depois de dizermos que Garfield está com saúde é a primeira vez aqui. Então, no final da segunda linha , execute um código e pronto. Agora disse que um gato foi criado com os seguintes atributos chamados Garfield H2, Health 100. Garfield, sua saúde é 100. Em seguida, mudamos isso com nossa função de alteração de integridade, que pudemos acessar usando apenas o nome de nossa instância ou objeto aqui porque essa função era pública. E então pudemos mexer com o membro privado sendo a saúde da classe animal da qual deriva, porque tínhamos esses caçadores e criadores disponíveis para nós. E então imprimimos sua saúde, novamente com 85 anos, já que acabamos de tirar 15 dela, acabamos de criar um cachorro que fez a mesma coisa. Se imprimirmos um cachorro criado com os seguintes atributos, nomeie spotty age 300. Então aí está. De qualquer forma, eu sei que provavelmente foi muita coisa que absorve. Então, vamos voltar e revisar todo o nosso código aqui rapidamente. Então, vou ampliar um pouco aqui e minimizar tudo o que temos até agora. Então, vamos seguir em frente e começar do topo. Como eu sei, estamos trabalhando com esses códigos há algum tempo , pois aprendemos e os adicionamos passo a passo. Então, criamos uma classe chamada animal, depois damos a ela alguns membros públicos e privados. Agora, vamos começar com membros privados. Então, primeiro, dissemos essencialmente que todo animal terá um nome. Vamos armazenar isso em uma sequência de caracteres. Eles terão uma idade que armazenará um número inteiro e um valor de saúde. Também será armazenado em um número inteiro. E toda vez que um animal é criado, vamos prosseguir e inicializar esses valores. E fizemos isso com nosso construtor, que, se você se lembrar, há apenas uma função que será chamada automaticamente sempre que um animal for criado. Para fazer isso, usamos nosso nome de animal aqui, seguido por alguns parâmetros que queríamos considerar, na definição que temos aqui embaixo. Portanto, ele não executa nenhum código sozinho, mas usa uma string e um inteiro, um para nossa variável de nome em um para a variável de idade. E usamos uma lista de inicializadores aqui com dois pontos seguida por cada membro que queríamos definir em ordem. Então, ele disse que o nome do sublinhado é o nome do nosso membro, eles serão definidos como iguais ao nome ou ao argumento que foi passado para esse parâmetro. Então fizemos o mesmo com H aqui. E, por fim, demos saúde e valor inicial de 100 toda vez que não aceitamos nenhuma contribuição do usuário para este. Aqui. Vou continuar e minimizar isso agora. Em seguida, criamos um getter for health, ou apenas uma função que nos permitiu obter o valor de nossa variável de saúde privada. E isso foi para encapsulá-lo para que ele só possa ser trabalhado dentro dos perímetros que decidimos, é por isso que temos um getter e setter para ele, bem como esse método de mudança que acabamos de adicionar. Então, vamos examiná-los agora. Portanto, obter saúde não requer nenhum parâmetro. Tudo o que ele faz é devolvido ao chamador ou ao código que está chamando essa função AND OR do método. Então, eles retornam um número inteiro porque nosso membro de saúde é um número inteiro e apenas retorna saúde. Então, se você quiser saber o que é saúde, você pode chamar essa função e nós a daremos a você. E poderíamos ter colocado qualquer outro código aqui que quiséssemos, mas essa foi apenas uma sarjeta básica que decidimos criar. Então, temos outra função para definir a saúde. Isso permite que a cor insira qualquer valor de saúde desejado e definiremos Saúde igual a ele. No entanto, inserimos um código extra aqui para dizer: Ei, teremos uma saúde máxima e uma saúde mínima. Portanto, se a saúde, depois de ser definida como qualquer coisa que o usuário inseriu aqui, seja maior que 100. Ei, vamos colocar esses 200 de volta. E se for menor que zero, vamos prosseguir e defini-lo como igual a zero. Em seguida, acabamos de criar essa nova função chamada alterar a saúde, que permite que a cor altere o valor da saúde em qualquer quantidade que ela invista. Então eles enviam nossa função aqui, um número inteiro e adicionamos esse valor à saúde. E isso poderia ter sido um número negativo ou positivo, e seria adicionado. Então a mesma coisa. Dissemos: Ei, se a saúde agora for maior que 100, vamos reduzi-la para 100 e a saúde for menor que zero, vamos defini-la como zero. E poderíamos ter inserido qualquer código extra que quiséssemos aqui para que pudéssemos realmente imprimi-lo de volta para a saúde do usuário se isso, Andrew foi alterado para isso ou o que quiséssemos, mas acabamos de criar um função básica para mudar a saúde por qualquer coisa e depois garantir que ela não ultrapassou o máximo que queremos e a quantidade mínima que queríamos. Também poderíamos ter criado alguns getters e setters para o nome e a idade. Mas acabamos de fazer isso aqui por uma questão de simplicidade. E, por fim, temos uma última função para nossa classe animal, que apenas permite que qualquer objeto do animal diga falar, junto com a inserção de uma string. E ele simplesmente imprimirá esse som lá. E podemos até voltar a isso e fazer um pouco mais com isso em um vídeo posterior. Então, de qualquer forma, espero que tudo isso tenha feito sentido para você. Vamos prosseguir e transferi-lo para nossa classe de cães. E vamos simplesmente ignorar a classe dos gatos, pois ela será exatamente a mesma essencialmente. Então dissemos que o cão da classe herdará do animal da classe e qualquer membro que herdássemos, queríamos deixar com a mesma acessibilidade exata antes. Portanto, qualquer membro privado permaneceu privado. No entanto, não temos acesso a eles porque membros privados só estão disponíveis na classe em que foram criados. Mas obtivemos acesso ao público e aos protegidos, e eles permaneceram públicos e protegidos aqui. E como podemos proteger? Todo o público teria sido protegido. E como definimos o privado? Tudo teria sido feito antes disso. Mas lembre-se de que teríamos tido acesso a essas variáveis, exceto aquelas que eram originalmente privadas do animal. Então, por exemplo, o que quero dizer com isso é que se disséssemos antes dessa função pública de saúde animal, por exemplo agora estaria aqui essencialmente o que acabou de tornar privado. OK. Então, de qualquer forma, acabamos de deixar os membros enquanto eles trabalham. E então dissemos público aqui e criamos um construtor para cães. Então, para fazer isso, dissemos cão seguido por alguns parâmetros. Então, escolhemos um nome e uma idade para combinar com o que nosso animal levou aqui. OK. Isso porque sempre que um cachorro é criado, um animal também é criado essencialmente porque um cachorro é um animal e porque não tínhamos um construtor padrão que não levasse nada. Precisamos ter um construtor que corresponda ao único construtor disponível para anima. E lembre-se, poderíamos ter criado vários construtores para animais e vários para cães, mas fizemos isso dessa maneira. Posso garantir que sempre que um Douglas criasse um dado sem nome e uma idade fosse dada, poderíamos ter colocado quantas coisas quiséssemos. Poderíamos ter colocado um nome e uma idade, uma raça ou algo parecido em nosso construtor de animais em Londres. O mesmo aqui, mas fizemos dessa maneira por simplicidade. E então o que fizemos foi criar outra lista de inicializadores para chamar o construtor essencialmente para animal diretamente daqui. Portanto, qualquer nome e idade foram inseridos quando um cão é criado, agora será inserido no nome e idade do nosso construtor de animais. Porque, como eu disse, toda vez que um cachorro é criado, um animal é criado e nós fizemos isso diretamente dessa maneira. Mas com todo o tecnicismo, como queremos que isso aconteça? poderíamos ter pego nada, criado uma variável chamada string, name, equal to spot e apenas papai noel em nosso construtor de animais toda vez que um cachorro era criado. Em seguida, imprimimos um monte de coisas. E isso é bastante autoexplicativo. Já trabalhamos com funções antes, tudo bem, e depois fizemos exatamente a mesma coisa com o gato. Obviamente, essa classe se chamava gato e dissemos uma incontável nota em vez de cachorro, O que é classificada? E, finalmente, se viermos até aqui, criamos um gato chamado meu gato, e demos a ele o nome de Garfield e tinha dois anos de idade. Em seguida, imprimimos Garfield como saúde é, e depois usamos a função getter, certo? E conseguimos acessar isso diretamente do meu gato porque ele era um membro público. E quando o herdamos, ainda era possível que o público acessasse isso assim e obtivesse o valor da Saúde. Então mudamos essa saúde porque essa também era uma função pública e a imprimimos novamente quando acabamos de criar uma escuridão aqui embaixo. Então aí está. Só para te mostrar uma coisa aqui. Se eu fosse até nossa aula de gatos aqui e mudasse animal público para proteger o animal e tentar executar nosso código. Você verá que recebemos um erro. E isso porque agora essas funções, diz respeito a um gato, porque essa é a classe com a qual estamos trabalhando, está protegida, o que significa que não estará disponível para nada diferente de si mesmo e de quaisquer classes que dela herdem ou derivam dela. Da mesma forma, se tivéssemos dito privadas, isso teria tornado essas funções privadas no que diz respeito ao gato, e elas não estariam disponíveis para nós aqui. OK. Então, só queria mostrar como isso funciona lá, já que tínhamos um exemplo razoável disponível para nós. E agora eu coloco isso de volta ao público em nosso código funciona mais uma vez. No entanto, só para mostrar mais uma coisa sobre isso, se eu fosse em frente e colocasse isso de volta no que como protegido ou mesmo privado, eles só seriam privados diz respeito a uma aula de gatos. Então, aqui embaixo, eu ainda poderia dizer algo como animal, meu animal. Dê um nome a ele. Vamos chamá-lo como Jeff ou algo parecido em uma idade de um ano. E nosso ponto e vírgula no final. E ainda podemos dizer que minha saúde animal é assim. Nisso funcionará muito bem. Isso porque, no que diz respeito a um animal, obter saúde é pública, certo? E se eu comentar esse código aqui instantes e executar nosso código, você pode ver que isso funciona muito bem. Limpamos um cachorro, o nome de Spotty, com três anos de idade e saúde de 100. E então também criamos um animal. Mas observe que não imprimimos nada. E isso porque nosso construtor Animal não imprime mais nenhum texto. E a principal razão pela qual fizemos isso é porque, caso contrário, toda vez que criamos um cachorro ou um gato , não apenas como nosso construtor de gatos e cães seria chamado de bem, pois quando um cachorro ou gato é criado, um animal é criado. Tudo bem, e este é nosso único construtor disponível. Então aí está. E só para mostrar que isso funciona, aqui, posso dizer que minha saúde animal e o valor de pKa são 100. De qualquer forma, vou remover isso e descomentar essas linhas de código. E vá em frente e mude nossa classe de gatos aqui de volta para herdar animais públicos, não privados. Então aí está. Tudo está funcionando mais uma vez. E eu também removerei essa criação animal aqui embaixo. E eu sei que muitos dos nossos exemplos anteriores funcionaram com um código muito pequeno. Mas agora que aprendemos muitas coisas básicas e temos muito mais em nosso cinto de ferramentas. Eu queria seguir em frente e criar um programa maior com você lentamente ao longo de alguns vídeos, só para que você possa ver como isso poderia parecer no processo por trás disso e como colocar tudo junto peça por peça aqui. Então, espero que você tenha gostado deles. Enfim. Aí está você. Essa é uma espécie de resumo de tudo o que temos atualmente e que usaremos nos próximos vídeos de qualquer maneira, se você entendeu tudo até agora, parabéns. Você não terá problemas nos vídeos daqui para frente. No entanto, para aqueles que estão tendo problemas, não se preocupe. No próximo vídeo, vou pegar tudo o que falamos com as aulas e dividi-lo em uma forma ou exemplo menor para você ver e trabalhar. De qualquer forma, isso é tudo para este vídeo. Mais uma vez, não se esqueça de salvar onde você tem. Obrigado por assistir, e nos vemos na próxima. 90. 89: Neste vídeo, vou pegar tudo o que aprendemos nos últimos vídeos sobre aulas e dividirei peça por peça, de uma forma mais básica. Como eu sei, havia muita coisa acontecendo na tela. Então, espero que este vídeo o ajude se você ficar um pouco confuso com tudo o que tínhamos acontecendo . Dito isso, não exclua o código que você tem, porque ainda o usaremos no próximos vídeos. Então, se você quiser acompanhar, recomendo salvar isso abrir um novo projeto, se quiser acompanhar aqui. Caso contrário, você pode simplesmente assistir o que eu tenho na tela e garantir que você entenda cada tópico à medida que avançamos. De qualquer forma, vamos começar. Tudo bem, primeiro, vamos em frente e voltar ao começo. Como criamos uma classe? Bem, deixe-me dizer classe seguida pelo nome. Então você pode dizer algo como animal, então teremos um conjunto de colchetes abertos e fechados e um ponto e vírgula no final. E aí está. É assim que você cria uma classe. Em seguida, no vídeo a seguir, falamos sobre como criar uma instância de uma classe. E bem, como fazemos isso? Bem, nós apenas dizemos o nome da classe seguido pelo nome do objeto ou dessa instância da classe. Então eu poderia dizer animal, meu animal, se eu quisesse. Basta colocar um ponto e vírgula no final. E agora criamos uma instância dessa classe aqui. Nesse caso, tem acesso e sua própria versão de quaisquer membros e/ou variáveis dessa classe. Então, se disséssemos o nome da string, assim, e por enquanto, forneceremos um valor padrão como esse. E agora meu animal aqui, ou exemplo de nossa classe animal aqui, agora tem sua própria versão ou instância desse membro ou variável aqui. E isso porque é seu próprio objeto animal, como sua própria instância ou versão da classe da qual é composto. Então aqui embaixo, poderíamos dizer que meu animal é o nome dessa versão, objeto ou instância ou o que você quiser chamá-lo de nome do ponto e defini-lo como ponto ou o que quisermos. No entanto, se vocês se lembrarem, quando se trata de classes, cada membro, variável ou atributo, ou o que você quiser chamá-lo da classe, é, por padrão, privado, o que significa que só está disponível para aquela classe. Então, se quisermos disponibilizá-la para os objetos ou instâncias da classe, precisamos torná-la uma entidade pública que possamos simplesmente dizer espaço público do cólon assim. E lá vamos nós. Agora, tudo aqui embaixo será um membro público. E se quisermos criar alguns membros privados, diremos algo assim e podemos colocar que quisermos lá embaixo. E eles só estariam disponíveis para a classe. Além disso, há um último especificador de acesso chamado protected, que os membros protegidos só estão disponíveis para a classe e quaisquer subclasses especificador de acesso chamado protected, em que os membros protegidos só estão disponíveis para a classe e quaisquer subclasses ou classes herdadas dela. E abordaremos isso aqui em apenas um minuto. Então, o nome é público. Podemos dizer que o nome do ponto do meu animal agora é igual a spot porque meu animal tem sua própria versão dessa variável de nome em, podemos provar isso fazendo o seguinte e criar outro animal e chamá-lo de meu animal matar. Digamos que meu animal significa que é igual a Salomão. E se você percebeu, nós apenas usamos isso como usaríamos com qualquer outra variável, exceto que temos que especificar a qual estamos nos referindo, já que cada uma tem sua própria instância. E, abaixo, imprimirá os dois. Então diga C do nome da minha dieta animal. E então diremos CL, nova linha, meu animal para mim. E como eu disse, porque cada um deles tem seu próprio nome. nome do meu animal é Spot e nome do meu animal 2 é Solomon. Então aí está. Outra coisa sobre a qual falamos foi criar um método em uma classe. E eu vou seguir em frente e mostrar a você a maneira correta de fazer isso. Então, deixe-me remover nosso segundo animal e imprimir o nome aqui. Tudo bem, agora temos apenas nossa classe que criamos mantida por uma string pública para que os objetos sejam instâncias dessa classe, tenham acesso a essa variável. Agora lembre-se de que cada um deles terá sua própria instância disso. E então não temos nenhuma variável ou função privada , mas também temos um espaço para isso aqui. Até agora, tudo o que fizemos foi criar um animal chamado meu animal e alterar seu nome para spot ou sua instância da variável name. Ok, então agora como criamos o método de classe? Bem, primeiro, criamos algo que se parece muito com um protótipo de função porque é basicamente a mesma coisa. Então, diremos algo como vazio, parênteses abertos e fechados e um ponto e vírgula no final. Assim, lembre-se, dentro de sua classe, você só quer suas declarações e fora de sua classe, você vai querer colocar suas definições. Essa é a maneira correta de fazer as coisas. Como eu disse no passado. Isso ajudará ao transferir nossa classe aqui para um cabeçalho e um arquivo CPP. E isso apenas torna as coisas mais limpas e abordaremos isso em um vídeo posterior. Mas agora, não se preocupe com isso. Vamos prosseguir com a criação dessa função. Então, o que temos aqui, então, criaremos o corpo real ou a definição da função. E vamos apenas dizer C para fora. Meu nome é espaço do cólon, assim. Dada a linha depois. E então, para especificar que essa função acabamos de criar como parte dessa classe animal aqui, copiaremos o nome da classe e o colocaremos logo antes do nome do nosso método. E então inserimos o operador de resolução de escopo ali mesmo. Agora declaramos e definimos uma função em nossa classe. E por causa do público, nosso objeto de uma classe ou uma instância dela também tem acesso a ela agora. E, na verdade, aqui em cima, queremos imprimir o nome também. Então, digamos que meu nome seja seguido pelo nome e depois, tudo bem, então aqui embaixo criamos uma instância de nossa classe animal, versão alterada da variável name. E então diremos o nome do meu animal print, sem mais nem menos. Abra e feche parênteses e um ponto e vírgula no final, porque chamamos isso da mesma forma que chamamos qualquer outra função. E se executarmos nosso código aqui, aí está. Meu nome é Spot. E outra coisa sobre a qual falamos é que esse tipo de animal funciona como qualquer outro tipo. Então, você pode realmente considerar isso como um parâmetro. Então, bem rápido, vamos remover essa função animal e aquecê-la aqui também. Então, agora temos apenas nossa única variável aqui novamente, n, ou movemos essa linha para lá. E então eu vou dizer um nome vazio. E entre parênteses pegará um animal, um animal. Então, aqui, vou ter um bloco de código e direi CL. Meu nome é um espaço. Vou imprimir o nome do animal. Então, diremos o nome do ponto do animal porque isso está criando uma cópia do que passamos, esse valor será o mesmo que passamos. Então, aqui em cima, eu posso dizer nome impresso e depois parênteses. Posso inserir meu animal desse jeito e colocar um ponto e vírgula no final. E precisamos de um protótipo de função acima. Então, vou apenas copiar isso. Eu pego isso e coloco um ponto e vírgula no final. E se eu executar meu código aqui, e aí está, imprimimos meu nome é, mas você também pode usar isso como um tipo de retorno. Podemos passar isso por referência, etc. Portanto, você pode usar isso da mesma forma que faria com qualquer outro tipo. A única diferença é que esse tipo é definido pelo usuário. Nós o criamos, essencialmente, tudo bem, porque definimos o que é um animal. Tudo bem, de qualquer forma, então eu vou me livrar disso. Uh, sim. Então, temos apenas algumas coisas básicas aqui. Em seguida, falamos sobre construtores, que são apenas funções especiais que são executadas automaticamente. Quando uma instância da classe é criada. Por padrão, você tem uma que se parece com essa. E, a propósito, todos os construtores devem ser públicos como um lembrete. Então, o construtor padrão é algo parecido com isso. Animal sendo o nome da classe, parênteses abertos e fechados e colchetes abertos e fechados. E se você criar seu próprio construtor, esse não existe mais. E você pode ter vários construtores que permitem sobrecarregá-lo de várias maneiras assim como você pode sobrecarregar funções. E por ter apenas dois construtores, você o está sobrecarregando. Cante porque o nome é igual ao nome da classe. Tudo bem, então vamos seguir em frente e criar um construtor. E vamos começar criando uma cópia da cópia padrão. Então, vou dizer algo assim. E aí está. Agora temos um construtor padrão. Se quiséssemos fazer isso corretamente, poderíamos declará-lo aqui e depois o limite finito. Bem, então não se esqueça, precisamos salvar o que essa pequena parte é. Então, vamos dizer animal segurado pelo operador de resolução de escopo animal, e depois nossos colchetes. Então, aqui está nosso construtor padrão. E é isso que nos permite criar um objeto ou uma versão de um animal sem precisar usar nenhum parâmetro. E isso porque isso não exige nada, mas podemos criar outro construtor que o faça. E então, antes que eu esqueça, lembre-se de que sempre que temos uma variável que é membro da classe, só queremos colocar um sublinhado antes do nome lá, só para sabermos, ei, isso é um Um membro da classe também deveria trocá-lo aqui. E como eu disse, podemos prosseguir e sobrecarregar esse construtor aqui. Acabei de criar outro construtor. E esse vai ser o que você chamaria, um construtor parametrizado. Porque vai precisar de alguns parâmetros. Então, aqui, vamos dizer o animal. E então, entre parênteses, diremos string, color. Assim. Não colocamos um ponto e vírgula no final. E então criaremos a definição para esse envelope. Vou apenas copiar isso e colar aqui. Em seguida, teremos nossos colchetes para o bloco de código. E então vamos dizer C out. Uma cor de conduta espacial. O animal espacial foi criado exatamente como aquele animal. Coloque um ponto e vírgula no final e temos que especificar onde esse construtor está vindo ou para que serve. Então, diremos animal antes dele, seguido pelo operador de resolução de escopo novamente. Então aí está. Agora temos outro construtor. E agora, se quisermos usar esse em vez dos padrões, vou apagar todo esse código. Podemos dizer animal. Animal. Entre parênteses, colocaremos uma string. Então, eu direi pessoalmente que coloque um ponto e vírgula no final. E se eu executar o código aqui, direi que um animal azul foi criado. E isso porque esse é o código que é executado quando criamos esse animal, já que esses são os parâmetros que usamos e outro uso para um construtor ou um dos principais usos dele é certifique-se de que sua turma esteja pronta para uso. E o que quero dizer com isso é que você quer ter certeza de que tudo tem um valor inicial. Como normalmente, você não quer fazer isso aqui, todas as suas declarações aqui e suas definições aqui embaixo. Tudo bem, então qual é a melhor maneira de dar nome e valor inicial em nosso construtor. Bem, logo após os parênteses, vamos dizer dois pontos, o nome do sublinhado entre parênteses colocará o valor. Então, vamos dizer aspas duplas e não colocaremos nada lá. E faremos o mesmo aqui embaixo, exceto que aqui embaixo, vamos dizer o nome do sublinhado. E então, entre parênteses, diremos o nome. E para obter esse valor aqui, adicionaremos outro parâmetro. Então, vamos dizer corda, cor, corda. Precisamos ter certeza de adicionar isso à nossa declaração desse método aqui em cima. Então, agora criamos outro construtor que usa uma string para a cor e uma string para o nome. E ele vai inserir qualquer nome que colocarmos em nossa variável de nome. A razão pela qual eu cometi o erro aqui é porque eu simplesmente não tinha aquele cólon ali. E aí está você, aqui embaixo. Recebemos um erro porque não temos mais um construtor que usa apenas um parâmetro. E se eu remover isso e colocá-lo parênteses abertos novamente, vou ver minhas diferentes opções de Vamos fazer. E diz que eu preciso de uma cor e um nome, ou eu simplesmente não poderia fazer nada já que temos esse construtor padrão. Então, como eu disse, o objetivo principal do construtor é preparar sua classe para uso inicializando todos os membros dentro dela. E então você também pode ter qualquer código que queira executar. Uma instância da sua classe é criada usando esse construtor. Como eu disse, a melhor maneira de inicializá-lo é com uma lista de inicializadores. E tudo o que você precisa fazer é dizer dois pontos seguidos pela variável e o valor que você deseja dar entre parênteses. E se tivéssemos mais de uma variável, diríamos vírgula. Em seguida, coloque-o no nome da outra variável e, em seguida, coloque esse valor e parênteses. E lembre-se de que eles precisam estar em ordem de cima para baixo, e você simplesmente vai da esquerda para a direita aqui. Então, vou remover isso, já que temos apenas uma variável. E aí está. Agora, eu posso ir em frente e colocar uma cor. Então eu poderia dizer azul novamente. E então nosso nome será spot. E agora que terminamos aqui, podemos dizer que um animal azul foi criado, chamado pelo nome. E lá vamos nós. Se eu executar meu código aqui, isso deve dizer que um animal azul criado chamado spot, e é isso que ele faz. Então, outra coisa sobre a qual falamos foi sobre o encapsulamento. Então, vamos dar uma olhada nisso. Basicamente, agora, eu posso mexer com minha variável de string. Eu poderia dizer o nome do meu sublinhado de pontos de animais e defini-lo como eu quisesse. E não há nada que me impeça. E isso pode não parecer grande coisa aqui, mas confie em mim, você não quer que seus membros sejam públicos. Se você puder evitá-lo, você quer ter tudo dentro de uma função getter e setter, que abordaremos aqui em apenas um momento para que você possa definir regras extras e colocar um código extra sempre que algo quiser mexer com uma variável. E se você decidir fazer algo com isso mais tarde, seu código agora é mais dinâmico porque você só precisa examinar essas duas funções em vez de tentar encontrar em todos os lugares onde a variável estava. ajustado. Então, vamos em frente e mudá-los. Primeiro, vamos pegar nossa variável de string aqui e colocá-la em privado aqui. Então, agora esse é um membro privado, que é o que você quer. E então, aqui em cima, criaremos duas funções para um getter e um setter. E antes de fazer isso, vou minimizar isso aqui. Então, não está no nosso caminho. Então, diremos set name como o nome da função e colocaremos um ponto e vírgula no final, e isso usará um nome de string. Em seguida, diremos getName abaixo dele. E isso não vai demorar nada. No entanto, ele retornará uma string. E esse aqui não retornará nada. Ok, então vamos dizer void, setName, nome string e String getName. E estará lá. Em seguida, ele criará as definições para os dois abaixo. Então, se eu copiar esse aqui e adicionar nosso bloco de código, o código mais básico para um setter seria fazer o seguinte. Eu diria que o nome do sublinhado é igual ao nome. E agora isso permitirá que qualquer coisa que chame essa função altere essa variável privada. Em seguida, faremos o mesmo com nosso método getName aqui. Ou a função criará a definição aqui embaixo, assim. E diremos o termo sublinhado nome. Então, precisamos ter certeza de que especificamos que essas duas funções fazem parte da nossa classe animal. Então, vamos dizer animal seguido pelo operador de resolução de escopo em ambos. E evite as necessidades que surjam antes disso. Certo, porque vai ficar logo antes do nome do método e da string contínua. Então eu vou para o outro lado, certo? E se executarmos nosso código agora, os animais azuis criaram o chamado spot, então tudo ainda está funcionando. E então aqui embaixo agora, se eu quiser mudar meu nome, eu tenho que dizer no meu animal die setName e, em seguida, colocar um valor de string aqui, como Solomon, por exemplo, colocar um ponto e vírgula no final. Você pode estar pensando, Ei, como isso é diferente? Bem, atualmente não é muito diferente de ser a maneira correta de fazer as coisas. Mas se eu tivesse isso em 100 lugares diferentes no meu código, onde eu estava mudando o nome ou qualquer variável isso era repetidamente. E eu decido, você sabe o que? Eu vou continuar e imprimir, ei, o nome foi alterado quando eu pude trocá-lo em 100 lugares. Mas como eu tenho o centro aqui, posso simplesmente dizer o nome do sublinhado CL. espaço foi alterado para seguir com um nome como esse e criar uma nova linha. E aqui embaixo são essenciais para o avião. E se eu executar meu código agora, agora ele dirá que eu aprendi o nome mais criativo e depois Spy, que mudou para Solomon. Ok, então aí está. É por isso que um getter e um setter são úteis e importantes. Especialmente se eu tivesse isso em vários lugares. Agora, eu não tenho que lidar com isso. Eu posso simplesmente olhar aqui e mudar minha coisa ali mesmo. Então, se eu acabei com algum tipo de erro ao alterá-lo, tudo o que preciso fazer é olhar meu código aqui e ver o que estava causando isso. Em vez de olhar para todos os cem lugares em que eu mexi com isso. E eu posso ter restrições aqui estão alguns códigos aqui para tornar a primeira letra maiúscula ou fazer com que o nome tenha apenas dez caracteres ou o que eu quisesse fazer, certo? Então aí está. É assim que você cria um setter e getter básico. E o que fizemos aqui, onde tínhamos a funcionalidade de nossa variável privada nessas funções públicas, é chamado de encapsulamento. E a última coisa sobre a qual falamos foi chamada de herança. Então, deixe-me ir em frente e remover tudo aqui bem rápido. E diga o seguinte. Digamos que a classe animal no meu bloco de código, e eu direi o nome da string, e também direi idade, assim mesmo. Então, todo animal terá um nome e uma idade. Lembre-se de que ambos são privados, então isso é exatamente o mesmo que dizer em privado. E isso porque os membros de uma classe são privados por padrão. Então, assim mesmo. E então vamos criar uma classe que herda da nossa classe animal. Então, essa será a classe base e a classe que está herdando dela será a subclasse. Então aqui embaixo, eu vou dizer cão de classe, por exemplo, herdar de um animal. E eu preciso ter um especificador de acesso aqui. E nesse caso, diremos público. E basicamente, se você se lembrar, se eu disser público, ouvir que tudo o que era público será transferido para o cão e será público. Tudo o que foi protegido será transferido para o cão e será protegido e tudo o que era privado. Bem, não é acessível fora disso, então realmente não importa se eu dissesse protegido, tudo o que fosse público seria transferido e protegido. Tudo o que estava protegido seria transferido para permanecer protegido e tudo era privado. Bem, não importa, não consegui acessá-lo de qualquer maneira. E então, se eu dissesse privado, tudo o que ainda não era privado seria transferido e tornado privado. De qualquer forma, vamos colocar algum código aqui. E, na verdade, vou mudar o especificador de acesso conosco para protegê-lo para que o cão tenha acesso a essas variáveis. E, obviamente, esse é apenas um exemplo muito básico. Portanto, não use o que estou fazendo aqui para insistir em como criar coisas. Eu só quero te mostrar o uso básico da herança. E lembre-se de que podemos herdar de várias classes seguindo isso com uma vírgula. Poderíamos dizer público e depois outro nome de classe e outras classes que herdam do cachorro, certo? E aqui embaixo, vamos clicar com o botão direito do mouse e criar uma variável pública, por uma questão de simplicidade, e adicionar um resumo. Então, todo animal terá um nome e uma variável de idade, e cada cão terá uma variável de raça junto com essas aqui. Ok? E agora poderíamos dizer , tudo bem, vamos criar um novo cachorro. Meu cachorro, assim mesmo. E como esses dois têm um construtor padrão, não preciso de nenhum parâmetro aqui. E se você quiser saber mais sobre isso, basta voltar ao último vídeo em que falamos sobre herança e se aprofundar mais. E então vamos criar alguns construtores para inicializar todos esses valores. E, na verdade, vou configurar essa aqui como privada. E eu peço desculpas. Eu esqueci de colocar um sublinhado em todos os nomes de nossos membros aqui. Então, vamos em frente e fazer isso. Bem, então, para inicializar isso, criaremos apenas alguns construtores. Então, vamos dizer animal. E este terá uma string, nome e idade. E colocaremos a definição abaixo. E especificaremos que, nessa parte da classe, teremos nosso bloco de código assim. Depois de nossos parênteses aqui, diremos apenas o nome do sublinhado de dois pontos. E então, entre parênteses, inserirá o nome. Diga que a vírgula sublinha a idade e, em seguida, os parênteses inserirão a idade. E então eu só queria adicioná-los. Nossos colchetes encaracolados são assim , só para não atrapalhar. E então podemos criar um construtor muito semelhante para o cão, exceto que adicionaremos a ele. E não se esqueça de que precisamos fazer nosso construtor aqui, cólon público de José Public assim. E só para fazer com que pareça um pouco melhor. E então, aqui para o nosso cachorro, criaremos um construtor. Mas antes de fazermos isso, diremos moedas privadas como essa para manter nossa corda. Em seguida, criaremos um construtor. Então, diremos que os parênteses dog e m usarão uma string para o nome, para a idade e uma string para o resumo. Em seguida, criaremos a definição abaixo. E não se esqueça, precisamos especificar a frente da classe de cães de Liz. E vou colocar alguns colchetes encaracolados como esse. Em seguida, colocaremos em nossa lista de inicializadores. Então, porque sempre que um cão é criado em, um animal é criado, já que derivamos disso, precisamos usar esse construtor também quando usamos nosso único construtor de cães aqui. Então, para fazer isso, vamos dizer animal, cólon, animal do cólon. E então, entre parênteses, diremos nome, vírgula H e assim. E estamos dizendo que estamos nos referindo a você como parte da classe Animal. Então queremos o construtor Animal. E vamos inserir esses dois valores aqui, que é o que nosso construtor de animais usa. E então podemos adicionar nossa raça para ser inicializada após esses construtores e um resumo de sublinhado por vírgula. M parênteses inserirão o resumo, e tudo isso funcionará bem. E então tudo o que você precisa fazer é mudar nossa declaração ou criação do nosso objeto canino. Então vamos dizer cachorro, e então eu vou chamar isso de meu cachorro. E entre parênteses, você pode ver que agora precisamos de três valores de construtor que correspondam ao nome. Então, vamos chamá-lo de spot, seguido por sua idade. Então, vamos dizer algo como dois. E então vamos continuar com uma raça. Então, podemos dizer boxer ou algo parecido e colocar um ponto e vírgula no final. E tudo isso vai funcionar bem. E podemos imprimir tudo abaixo ou até colocar o código para imprimi-lo dentro do nosso construtor de cães. E isso também funcionaria. E não se esqueça, esses dois construtores estão em execução quando criamos isso aqui. E só para mostrar que se eu dissesse CL, espaço do cólon animal, e aqui se eu substituir o cachorro, assim e executar o código, você pode ver que imprimimos animal e cachorro. E isso porque esses dois construtores estão funcionando. Porque quando um cachorro é criado, um animal é criado. E temos apenas um construtor aqui que assume três valores. Dois deles são usados como construtor de animais e, em seguida, também adicionamos uma raça. Tudo bem, então aí está. Esse é um exemplo básico de como usar a herança. cão agora tem essencialmente acesso às coisas desse animal, bem como às coisas do sul. E para levar esse ponto para casa bem rápido, um animal criará um método público chamado grito. E criaremos a definição abaixo. Então, vou copiá-los aqui embaixo. Diga Chow e especifica que é de um animal. E dentro de nossos suportes encaracolados aqui, diremos prateleira vazia, a propósito. Diremos que é um abrigo de animais vazio, assim. E então aqui dentro, vamos apenas dizer olá. E como o cão é derivado do animal, eles podem usar essa função, eles podem usar essa função, principalmente por ser pública. Então agora, aqui embaixo, eu poderia dizer que meu cachorro morreu, gritar. Se executarmos um código, você pode ver que ele funciona muito bem. Nós gritamos isso. Olá. E eu vou remover a impressão de cães e animais aqui. Já. Entendi esse ponto. E eu o executo novamente para você. E como você pode ver, ele só diz olá. E mesmo que nosso método exista, nossa função estava protegida. Assim, teríamos tido acesso a ele dentro da própria classe. Então, se eu remover essa linha de código aqui e dentro do nosso construtor, por exemplo, eu poderia ter usado shell. Portanto, o código com interclasse terá acesso a essa variável protetora, pois está disponível para a classe e para qualquer coisa que deriva dela. Então eu posso dizer grite aqui, agora vá em frente e mude para que fique um pouco mais legível para vocês e rodem nosso código. E agora, quando criamos um cachorro, ele grita olá. E poderíamos ter colocado isso em uma função ou algo assim para o nosso cachorro também. E isso teria funcionado da mesma forma. E se tivéssemos outras variáveis ou funções protegidas ou públicas, teríamos acesso a elas dentro do código de nossa classe de cães. Então, só para mostrar um exemplo, eu poderia dizer x e esse não é um ótimo exemplo de como usá-los. Mas você entenderá o ponto aqui embaixo. Eu poderia ter dito algo como x é igual a dez e depois imprimir x na linha. E se eu executasse meu código, ele teria funcionado muito bem porque nossa classe aqui tem acesso ao código. No entanto, mesmo que o código tenha acesso a um aqui, não teríamos sido capazes de dizer algo como meu cachorro, x é igual a dez, por exemplo, isso não teria funcionado, mas teria funcionado se fosse público. Aí está você. O código funciona muito bem, ou podemos até mesmo imprimi-lo assim. E isso também funcionará. Então, deixe-me ir de qualquer maneira. Espero que este vídeo tenha ajudado você um pouco se você estivesse recebendo um grande corte e todo o código extra que tínhamos na tela antes. Obrigado por assistir, e nos vemos na próxima. 91. Capítulo 15 (aulas): palavra-chave estática: Neste vídeo, vamos dar uma olhada na palavra-chave estática em C plus plus. Agora, a palavra-chave estática pode ser aplicada a coisas como variáveis, funções e objetos. E exatamente o que ele faz vai mudar dependendo do que está conectado. E daremos uma olhada breve em quatro exemplos diferentes de como e quando e podem ser usados para que, se você o visse no futuro, não tivesse uma ideia do que é agora. de forma geral ou ampla. Embora você possa pensar quando vê a palavra-chave estática como se o que quer que ela esteja vinculada agora é permanente e será a única cópia dela. E vamos dar uma olhada exatamente no que quero dizer com isso aqui em um momento. Então, primeiro vamos dar uma olhada na palavra-chave estática quando ela é usada em variáveis e funções. Como você pode ver aqui para a definição ou como isso funciona, eu basicamente disse que ela cria uma cópia permanente e única de uma variável. Então, vamos criar uma função acima da principal aqui para ver um exemplo disso. Então, o que vamos fazer é dizer Boyd, conte o tempo, dram, assim, abra e feche parênteses. E criaremos o bloco de código dentro daqui. Vamos dizer estática. Na faculdade, eu o defino como 0 e, abaixo disso, direi I mais, mais assim. E então, dentro daqui, vamos também imprimir. Então, coloque-o em uma nova linha a cada vez. E então, aqui em nossa função principal, vamos chamar esse método cinco vezes. Então eu vou continuar e comentar nosso outro código aqui. Por enquanto. Nós vamos simplesmente acontecer da seguinte forma. Quando nosso método for executado aqui pela primeira vez, ele será executado e criará uma variável inteira estática chamada i e a definirá como igual a 0. E se você se lembrar, eu disse que essa variável agora será permanente e a única cópia dessa variável. E o que isso significa é que, quando for executado pela primeira vez, ele o criará e o definirá como igual a 0. E por ser estática, essa será a única cópia da nossa variável inteira chamada i dentro do escopo aqui. Então, ainda não podemos dizer algo como I é igual a dez aqui sem cometer um erro , porque ainda está apenas dentro desse escopo. Em seguida, ele imprimirá I, que será 0, e depois aumentará I em um. Agora, normalmente, se essa não fosse uma variável estática, ela criará uma nova variável chamada I. Cada vez que esse método for executado, imprima 0 aumentos em um. Da próxima vez, crie outro inteiro chamado Conjunto de matrizes igual a 0, impresso e cristalino por um e assim por diante. E sempre obteríamos o mesmo resultado. E se executarmos nosso código sem a palavra-chave estática aqui rapidamente, você pode ver que esse é o caso. Então aí, imprimimos 05 vezes, já que chamamos o método cinco vezes. Mas se colocarmos estática aqui e lembrarmos que tudo está em minúsculas. E antes do tipo de dados, quando executamos nosso código agora e na verdade, aumentamos em um a cada vez. E isso porque quando chamarmos nosso método novamente, porque eu já fui criado após a primeira vez, ele usará a mesma variável. Então, essencialmente, na segunda vez por aqui, essa linha superior será ignorada. Na impressão, eu aumentei em um. E então, quando ela voltar em torno de L, ignore essa linha novamente porque eu já criada e haverá apenas uma cópia dela. Então, toda vez que chamamos esse método agora, essa declaração e inicialização aqui são ignoradas e imprimiremos i e depois aumentaremos em um. Então aí está. É assim que a palavra-chave estática funciona com variáveis em funções. Ele cria uma cópia permanente e única da variável. E você pode estar se perguntando o que aconteceria se fizéssemos algo assim e executássemos um código? Bem, agora, como apenas essa linha superior, ela será ignorada onde isso foi declarado, serei definido como igual a 0 a cada vez e, em seguida, ele imprimirá 0. Então, se você vai fazer algo assim, você deve inicializá-lo na mesma linha para que isso possa ser ignorado no futuro. De qualquer forma, podemos excluir essa função agora, bem como excluir as chamadas para ela, e passar para esse segundo caso de uso para estática, que tem variáveis nas classes. E o que isso faz é criar uma variável permanente que é compartilhada entre todos os objetos dessa classe. Então, o que vou fazer é descomentar nosso código aqui, assim mesmo. E então poderíamos colocar isso na classe de cachorro, gato ou animal, e funcionaria da mesma forma. Então, vamos colocá-lo em nossa classe de cães aqui. Só como exemplo, o que vamos fazer é dizer estático. Vou colocar um ponto e vírgula no final. E então o que precisamos fazer para inicializar isso aqui, eu digo estático. E então cachorro é o nome da classe, dois pontos, dois pontos ou o operador de resolução do escopo. E então diga, eu, defina como 0, por exemplo. E, na verdade, removeremos a palavra-chave estática pela segunda vez. Então, vamos apenas dizer cólon de cachorro, cólon I é igual a 0. Estamos usando essa variável de número inteiro estático, que já criamos. E não precisamos usar a palavra-chave estática após esse ponto. E então nós o inicializamos fora da classe dizendo que int é o inicializamos fora da classe dizendo que o tipo mantido pelo nome da classe com operador de resolução de escopo e, em seguida, o nome da variável, definindo-a igual a 0. Então, observe aqui que depois de criar a variável, você não precisará mais usar a palavra-chave estática ao se referir a ela no futuro. E a única razão pela qual usamos anterior é apenas por causa de como essa variável é inicializada quando é colocada em uma classe. É uma variável estática e essa é a maneira de fazer isso. Mas normalmente podemos nos referir a isso como “Eu sou um recurso”. E vamos seguir em frente e tornar isso público para que possamos facilmente dar uma olhada em como isso funciona. Então, aqui embaixo, já temos um objeto ou uma instância da nossa classe de cães chamada meu cachorro. E vamos salvar meu ponto e defini-lo como cinco. Então vamos criar outro cachorro, meu cachorro também. E vamos dar a isso um nome como sparky e dar a ele uma idade de dois anos, por exemplo. Então vamos imprimir meu cachorro para ver como ele também. E vamos colocar isso em uma nova linha, assim, criar uma nova linha depois dela, devo dizer. E se executarmos nosso código, você pode ver que aqui embaixo, meu cachorro que morreu tinha cinco anos. E isso porque essa variável inteira estática , conforme escrita aqui, é uma variável permanente que é compartilhada entre todos os objetos dessa classe. Portanto, não importa quantas instâncias da classe criamos, todas elas compartilharão a mesma variável. Então, se disséssemos que meu cachorro para mim é igual a cinco e depois imprimisse meu cachorro. Eu pegaria dez e vou te mostrar isso agora. Então, se eu dissesse meu cachorro, dois pontos mais é igual a, bem, nós originalmente dissemos que eu era igual a cinco e agora apenas aumentamos em cinco. E como eles compartilham exatamente a mesma variável, se imprimirmos meu cachorro, eu imprimirei dez. Ok. Então aí está. Como eu disse, nós realmente poderíamos ter dito, eu criei essa variável estática no animal aqui. E então não só toda instância de gato compartilharia essa variável, já que é um animal. Mas cada exemplo de cão também teria, além de cada instância de animal, que teríamos criado dois. Então, tudo o que é um animal teria compartilhado essa variável. Para que você tenha, de qualquer forma, vou remover isso do cachorro aqui. E também removeremos esse código extra. Vamos dar uma olhada no terceiro caso de uso da variável estática. Então, se eu criar um objeto de classe estática, o que ele faz é criar uma cópia permanente e única desse objeto. E provavelmente a maneira mais fácil de mostrar isso seria criar outra função. Então, aqui vamos dizer vazio, criar objeto, abrir e fechar parênteses. E então teremos nossos colchetes encaracolados assim dentro daqui. Vamos criar um cachorro chamado meu cachorro. Muito triste. Então, daremos um nome a ele. Então, vamos dizer sparky e dar a ele uma idade como a de. E depois disso, diremos que meu cachorro morreu, mudou a saúde. E diremos que menos cinco são considerados valores de menos cinco. E depois imprimiremos que meu cachorro tem saúde, assim. E vamos imprimir isso em um ângulo. Meu cachorro temporário não busca ajuda. Line, assim mesmo. Em seguida, chamaremos essa função algumas vezes. E nosso método principal. Agora, quando nosso código é executado e ele chega a essa função, L, crie um cachorro, meu cachorro, e dê a ele o nome de sparky e uma idade de dois anos. Então vamos dizer que meu cão temporário altera a saúde menos cinco, que mudará sua variável de saúde, que, se você se lembrar, tem um valor padrão de 100 e depois vai para imprimir 95. Então, da próxima vez, ele ignorará isso. Se fizermos isso de forma estática aqui, ou seja, dizemos que um cachorro assim, da próxima vez, ignorará isso, assim como aconteceu com a variável estática que tínhamos em uma função, porque meu cão temporário já foi criado e só pode haver uma cópia dele e ele é permanente e , em seguida, diminuiremos a saúde que tive novamente e o imprimiremos. Então, se executarmos nosso código aqui, você pode ver que a defini em 95 meses porque começou 100 subtrair 05 impresso e, em seguida, diminuirá em cinco cada vez que o chamarmos. E então, só para mostrar que isso só aconteceu por causa da palavra-chave estática, se removermos isso e executarmos nosso código, você verá que nosso construtor de cães realmente vai corra quatro vezes. Então, depois que o corpo do nosso cão foi criado pela primeira vez aqui, executamos essa função que criou um novo cão chamado sparky H2, imprimiu sua saúde. E então aqui embaixo, depois de subtraída, sua saúde é impressa novamente. E então fizemos a mesma coisa por mais vezes. Então, da próxima vez e leia esse código novamente, dê crédito a outro cão chamado sparky H2 Health um 100 impresso novamente, e eles vão e continuam repetindo. Então, quando adicionamos estática aqui, toda essa linha é ignorada. Então, com essa estática, isso cria uma cópia permanente e única disso. E toda vez que essa linha é executada novamente, ela fica. Então aí está. Objetos de classe estática e variáveis estáticas em funções funcionam da mesma forma. Agora, vamos analisar mais um caso de uso para isso. Essas são funções estáticas nas classes. Mas antes de fazermos isso, vamos remover esse código aqui junto com a própria função. Tudo bem, então vamos dar uma olhada agora nas funções e classes estáticas. Então, se formos até nossa classe de animais aqui, por exemplo, e dentro do público, criaremos uma função estática. Nós podemos fazer isso assim. Vamos dizer static, void, print, hello, abrir e fechar parênteses e um ponto e vírgula no final. E então vamos defini-lo aqui apenas para uma boa prática. Então, vamos dizer animal, cólon, olá, abrir e fechar parênteses. Em seguida, criaremos o bloco de código aqui embaixo. Então, antes do animal, ainda precisamos dizer para evitar isso, porque essa é a nossa declaração de devolução. Mais uma vez, observe que não precisamos usar a palavra-chave estática novamente. E então aqui embaixo, eu vou, vamos fazer e dizer olá depois, sem mais nem menos. E agora, em qualquer instância da nossa classe animal, teremos apenas uma versão dessa função. Além disso, como há apenas uma versão dessa função, não é permitido acessar variáveis não estáticas. Então, por exemplo, não podemos dizer que a idade do sublinhado é igual a cinco. Se eu passar o mouse sobre isso, você verá que uma referência de membro não estática deve ser relativa a um objeto específico. E o que isso significa é que, como nossa função é estática e que não há uma nova instância dela para cada objeto da classe animal que criamos, é que eles não podem usar instâncias específicas dessa variável, pois há uma idade sublinhada para cada objeto de nossa classe. No entanto, ele pode usar variáveis e funções estáticas. Então, se tivéssemos algo como estática, eu gosto para que ela pudesse ser usada, então aí está. E lembre-se também de que, ao usar uma variável estática, temos que dizer cólon animal, cólon e, em seguida, inicializá-la assim. E ainda precisaríamos ficar aqui também. Então aí está. Funções e classes estáticas são compartilhadas entre cada objeto dessa classe. E eles só podem usar variáveis e funções estáticas , pois não são específicas para cada objeto. Agora, se mudarmos isso para algo como i mais igual cinco e depois formos até aqui e criarmos alguns animais. Então, se for um animal, um animal terá que lhe dar um nome e idade. Então, diremos Jack, um ano de idade. E eu vou dizer animal para dizer que Karl B também é um. E então podemos dizer animal de um quilo, exatamente assim. Olá, estampas de animais Em ambos, funcionará muito bem. E eles estão compartilhando a mesma função aqui. E só para mostrar algumas coisas com isso, podemos dizer algo como x é igual a cinco. E então diremos x plus assim. E então diremos que eu mais é igual a cinco. E imprimiremos o seguinte. Nós diremos que x é igual. Para imprimir x. Principalmente Cl I é igual. E colocaremos esses dois em suas linhas também. Agora, chamamos essa função duas vezes. Lembre-se de que eles compartilham exatamente a mesma função. E antes de executar um código, na verdade precisamos de parênteses aqui, assim como faríamos com qualquer chamada de função, a propósito, caso eu tenha esquecido de mencioná-lo anteriormente no curso. Às vezes, quando as pessoas estão falando sobre chamar uma função, elas também podem se referir a isso como invocar a função, certo? Então, só um aviso sobre isso. Isso significa que a mesma coisa a invocar na chamada de uma função é a mesma. Agora, se executarmos um código aqui, você pode ver que ele imprimiu Hello porque x não era uma variável estática. Era o mesmo toda vez que esse código RAM, no entanto, eu era uma variável estática. Então, toda vez que essa função era executada, ela trabalhava com a mesma variável. Então, a primeira vez imprimimos cinco e a segunda vez imprimimos dez. E a coisa básica a se lembrar sobre uma função estática é que cada instância da classe compartilha a mesma função e que ela só pode usar membros e funções estáticos. E há mais uma coisa importante a ser observada sobre as funções estáticas nas classes. E isso porque a função é estática e não há uma nova versão dela por objeto ou instância da classe. Na verdade, você pode chamar essa função sem criar nenhum objeto. Então, o que podemos fazer aqui é dizer cólon, cólon de animais ou o operador de resolução de escopo. E então basta dizer “olá”. E isso vai funcionar muito bem. E aí está. Fui aumentado em cinco novamente porque era uma variável estática e pudemos usar a função sem ter nenhum objeto. Então, isso é muito legal. Agora, tenho certeza de que você já pode pensar alguns casos de uso diferentes de quando você pode querer uma variável permanente em uma função, bem como quando você gostaria uma variável estática em uma classe. Por exemplo, poderíamos usar isso para que uma função contasse quantas vezes ela foi usada. E então o mesmo por aqui. Poderíamos simplesmente aumentar nossa variável estática um e cada um de nossos diferentes construtores para uma classe. E então saberíamos quantos objetos foram criados dessa classe. E esse é apenas um exemplo para você, para cada um deles. E então já vimos um exemplo de quando você pode querer usar um objeto de classe estática, onde pudemos criar uma função que criou um objeto dentro de seu escopo especificamente e foi capaz de faça algo com o objeto toda vez que ele for executado, sem que ele esteja fora desse escopo e sem criar um novo a cada vez. Por fim, funções e classes estáticas. Um dos principais casos de uso, motivos para usá-los, é aqui mesmo, onde podemos chamar essa função sem criar uma instância dessa classe. Isso pode ser muito útil. Por exemplo, se você teve algo como uma aula de matemática, bem, você provavelmente não precisa de uma instância da sua aula de matemática. Em vez disso, talvez você queira usar todas as funcionalidades disponíveis nele. E esse seria um caso de uso perfeito para isso aqui. De qualquer forma, existem quatro casos de uso diferentes da palavra-chave estática e alguns exemplos que a acompanham , bem como alguns casos de uso. Então, se você ver isso no futuro, espero que não esteja completamente perdido no que é e por que isso acontece , e quem sabe? Talvez até o usemos em um de seus próprios programas. De qualquer forma, antes de encerrarmos este vídeo, vou excluir esses textos extras que criamos neste vídeo. Deixe que seja como era quando começamos. De qualquer forma, não consigo ver. Agradecemos por assistir e nos vemos na próxima. 92. Capítulo 15 (aulas): curso vs estrutura: Neste vídeo, falaremos sobre as diferenças entre estruturas e classes em C plus plus. Agora, eu sei que nem sequer examinamos estruturas ou estruturas, mas confie em mim, se você sabe quais classes você basicamente sabe o que são estruturas. Então, vamos dar uma olhada na sintaxe de ambos. E depois falaremos sobre as diferenças reais e por que você deve usar uma em vez da outra. Então, nas duas primeiras classes de crédito, como sabemos, você vai dizer algo como classe. Você precisará abrir e fechar colchetes e um ponto e vírgula no final. E um pouco para criar uma estrutura, você vai dizer estrutura, ou eles abrem e fecham colchetes e um ponto e vírgula no final. E aí está. Essa é a sintaxe de uma estrutura. E essa é a sintaxe de uma classe. Então, qual é a diferença? Bem, no que diz respeito à nossa teoria do programa, ou ao compilador, isso realmente não importa. Isso pode muito bem ser exatamente a mesma coisa exceto uma diferença fundamental. E não deixe que ninguém lhe diga nada diferente, porque na verdade, as pequenas diferenças sob o capô não farão nenhuma diferença. Então, o que faz essa diferença fundamental? Bem, os membros da classe, se você se lembrar, padronizam para privados assim, e os membros da estrutura usam o padrão público. E aí está. Essa é a diferença entre uma classe e uma estrutura. Então, só para esclarecer aqui, na tela, os membros de uma classe têm acesso. Os membros de uma estrutura, por padrão, são públicos. E, a propósito, quando estou falando sobre a diferença entre eles, estou me referindo apenas ao C plus plus e às outras linguagens de programação. Então aí está. Essa é realmente a única diferença entre uma classe e uma estrutura, além da palavra-chave aqui ser estrutura ou uma classe correspondente. Então, por que você usaria uma estrutura em vez de uma classe ou vice-versa? Agora, com todo o tecnicismo, você pode usar o que quiser. Legal. Como eu disse, eles são basicamente os mesmos, exceto a acessibilidade padrão de seus membros, que você sempre pode mudar de qualquer maneira. Mas, de um modo geral, se outro programador ou algo assim examinasse seu código e visse um derrame, eles assumiriam que você essencialmente não terá nada que seja privado ou oculto e que praticamente tudo dentro dela será público. Então, se você quiser criar uma classe de algum tipo, talvez seja uma classe para funções matemáticas ou algo parecido. E tudo será público e disponível e você não tem motivos para esconder nenhuma informação, então vá em frente e use uma estrutura. Caso contrário, se você planeja ter algum membro privado ou protegido, verdade, eu recomendaria usar uma classe e isso é como uma coisa do tipo convencional. Mas, como eu disse, e todos os detalhes técnicos e C plus, eles são essencialmente a mesma coisa, mais clara do que essa única diferença. Portanto, use o que você preferir, mas essa é apenas a forma convencional de usar uma estrutura, quando você não terá nada privado ou protegido. De qualquer forma, isso é tudo para este vídeo. Então eu vou apagar esse casaco. Obrigado por assistir, e nos vemos na próxima. 93. Capítulo 15 (aulas): evitar a criação de classes base: Neste vídeo, falaremos sobre como podemos tornar nossa classe base instanciada ou credível. Então, atualmente em nosso código, podemos criar um Animal Crossing e depois dar um nome a ele. E depois com um nome para o animal, como exemplo brilhante, e dando a ele um H. Então, isso vai funcionar bem. Mas e se quiséssemos fazer com que você só pudesse criar uma instância de um cachorro ou gato sendo nossas classes que herdam do animal ou das subclasses da classe base animal. Bem, é bem simples, mas temos que ir até nossa classe de animais aqui. E se abrirmos isso, você pode ver nosso construtor aqui. E lembrem-se de como eu disse a vocês que um construtor precisava ser público. Bem, isso foi para que pudéssemos criar uma instância dela, pois o construtor precisa estar disponível para fazer isso. Mas nesse caso, como já temos subclasses de gato e cachorro com as quais queremos trabalhar em vez de animais diretamente, tudo o que precisamos fazer é cortar nossa declaração de construtor aqui. Em seguida, adicionaremos protected como especificador de acesso. Então, vamos dizer mina de carvão protegida, assim mesmo. E logo abaixo disso, vamos simplesmente colar nosso construtor. E agora, a única coisa que tem acesso a esse construtor é a própria classe e suas subclasses ou qualquer coisa que herde da classe Animal. E agora, se tentarmos ir até aqui e criar qualquer animal, teremos um erro. E isso porque não há mais um construtor disponível para nós. E aí está. É assim que você pode tornar uma aula confiável. Mas lembre-se de que você realmente não gostaria de fazer isso a menos que tivesse uma subclasse ou algo parecido com a qual trabalhar. Em vez disso. De qualquer forma, vamos seguir em frente e deixar nosso código assim por enquanto. Então vá em frente e salve o que você tem. Obrigado por assistir, e nos vemos na próxima. 94. Capítulo 15 (aulas): operadores de acesso a membros: Neste vídeo, mostrarei uma forma diferente do operador de acesso de membros. Então, aquele com o qual trabalhamos até agora foi o ponto, mas há outra versão dele. E um exemplo de quando você verá isso é quando se trabalha com ponteiros para classes ou estruturas. Então, vamos dar uma olhada em como isso funciona. E, a propósito, o operador tem essa aparência, que é um traço e um símbolo maior que. Então, para ver isso, vamos seguir em frente e criar um ponteiro para uma classe. E nesse caso, faremos com que aponte para o meu gato. Então, vamos dizer asterisco PTR para planar e defini-lo como igual ao endereço de a. Tudo bem, então agora se imprimirmos mais limpo, assim, crie uma nova linha. E sabemos que isso imprimirá o endereço do meu gato em qualquer objeto aqui. No entanto, também podemos usar esse ponteiro para obter acesso aos membros do que está apontando. E, como eu disse, esse é apenas um exemplo de quando você pode ver esse operador. E não vamos entrar em todos os diferentes momentos em que você verá isso. Mas se você estiver interessado, fique à vontade para investigar isso. Eu só queria ter certeza de te mostrar um exemplo de um. Você verá isso, verá que não fica completamente confuso ao ver esses operadores. E decidi seguir esse exemplo porque ter ponteiros para objetos não é tão incomum. E então aqui embaixo, se dissermos PTR e depois tivermos nossa seta aqui, ou um operador de acesso para membros, você pode ver que eu imediatamente tenho acesso a todos os nossos membros do meu gato. Vamos seguir em frente e usar essas habilidades e obter ajuda. E o que esse operador de acesso de membros faz além de nos dar acesso ao membro é que ele também vai fazer referência a isso aqui. Então, em vez de nos dar o endereço agora, ele só vai correr para obter ajuda, que, como sabemos, retornaremos o valor de saúde do meu gato, que começou em 100 e o subtraímos em 15 aqui. Já imprimimos isso na tela como 85. Então, isso aqui também imprimirá 85. Se formos em frente e digamos “Veja assim”. E se executarmos um código aqui, você pode ver que imprimimos o endereço do meu gato. E executamos essa função aqui normalmente. E isso porque esse operador de acesso de membro, quando usado com ponteiros, não só nos dá acesso ao membro, mas às referências a ele. Então, em vez de nos dar um endereço, usamos esse membro normalmente. De qualquer forma, esse é apenas um exemplo de quando você verá esse operador. E se você estiver interessado, pode analisar outros casos de uso. Mas esse é aquele que fará este curso e o que você provavelmente verá com mais frequência. De qualquer forma, vou remover esse código extra. Não se esqueça de fazê-lo com segurança. Você tem. Obrigado por assistir e nos vemos na próxima. 95. Capítulo 15 (aulas): polimorfismo: Neste vídeo, falaremos sobre nosso quarto e último princípio principal e/ou pilar da programação orientada a objetos, o polimorfismo. E o que significa polimorfismo é assumir várias formas. De qualquer forma, vamos dar uma olhada em alguns exemplos de polimorfismo. Então, se formos para nossa aula de animais aqui, vocês se lembram, nós criamos esse método de falar. E se olharmos para a definição disso, tudo o que ele faz é pegar um som e imprimi-lo. No entanto, atualmente não temos essa versão específica para nossos cães e gatos ou quaisquer outras classes e subclasses infantis, talvez queiramos criar uma herança de nossa classe animal. Agora, atualmente, ter que inserir uma string específica sempre que usamos essa função e, em seguida, inserir o som que o animal emite especificamente toda vez que a usamos não é muito eficiente. Então, vamos corrigir isso usando polimorfismo. Então, a primeira coisa que vamos fazer é remover completamente esse perímetro. Tudo bem? E ele simplesmente imprimirá sons de animais assim. Tudo bem, e a razão pela qual estamos recebendo esse erro é porque, em nossa declaração aqui, também precisamos remover o parâmetro. Uma maneira de resolver nosso problema original agora com nossa classe de cães e gatos é fazer o seguinte. Primeiro, podemos simplesmente copiar toda essa função e colá-la em cada uma delas, assim. E agora, em ambos, só precisamos remover essa porção animal aqui. Então, agora diz apenas void speak e eu vou remover esses comentários também. Lembre-se, normalmente o que você vai querer fazer. Tenha a declaração aqui e a definição fora da classe. Mas vamos seguir em frente e deixar as coisas assim por enquanto. E nosso exemplo de qualquer forma, o que podemos fazer agora é na nossa classe de cães aqui, basta mudá-los para dizer Park e nossa classe de gatos aqui, podemos simplesmente mudar isso para dizer: Sim, isso funcionaria muito bem. Então, se formos até aqui, vamos imprimir alguns em branco. Então, lá embaixo, dirá que meu gato fala. E se você se lembrar, antes de substituirmos essas funções, isso teria simplesmente usado nossa definição que estava na classe base. Mas agora que os substituímos, podemos fazer o seguinte. Então diga que meu cachorro não fale agora e execute nosso código aqui. Você pode ver que imprimimos e latimos. E só para lembrá-lo de uma nova apresentação de como isso funcionava antes, se simplesmente removermos nossa implementação para a classe cat e executarmos nosso código novamente. Você pode ver que só dizia que os animais soam e depois marcam, certo? Então, embora isso funcione aqui, o problema é que ele realmente permite erros humanos. Porque agora, sempre que temos uma classe infantil que tem animais como classe parental, temos que nos lembrar de ter uma implementação do método de falar. Caso contrário, só vai dizer que os animais falam, o que não é o ideal. Queremos que cada animal tenha um som diferente embutido na classe. E normalmente, se você substituir uma função como essa e tiver a classe base animal, nesse caso, terá sua própria implementação. O que você quer fazer é realmente tornar essas implementações uma função virtual. E eu vou te mostrar o que é isso e por quê em apenas um segundo aqui. Então, se descermos até nosso código principal aqui e criarmos um ponteiro para nossa classe base. Então, se dissermos Astros animais, chamaremos esse animal de pisca-pisca. E vamos defini-lo como igual ao endereço do meu gato. A razão pela qual isso funciona, e você pode até mesmo solicitar um animal em um perímetro de função e usar meu gato como argumento, é o seguinte. E essa é outra forma de polimorfismo, na verdade, porque nosso gato é um animal, então sabemos que tudo a que esse animal tem acesso, gato tem acesso. Então, se solicitássemos um animal em uma função, por exemplo, executássemos algumas funções animais diferentes e trabalhássemos com algumas das diferentes variáveis dentro do animal. Bem, já sabemos que o gato implementou todas essas coisas porque nosso gato é um animal, pois ele herda do animal e, portanto, assume formas diferentes. Um cachorro não é só um cachorro, mas é um animal. O gato não é só um gato. Também é um animal. Mas não podemos usar o animal como uma implementação para cães ou gatos, por exemplo, porque nem todos os animais são gatos, mas todos os gatos são animais. Então, só funciona de uma maneira. Então é por isso que aqui embaixo, estamos dizendo, tudo bem, trabalho, posso criar um ponteiro para um animal e pegar o animal? Então, isso funciona. Tudo bem, mas o problema com isso é se eu dissesse cratera animal, então use nosso operador de acesso de membros. Lembre-se de quais ponteiros você usará um traço e um símbolo maior que. Parece uma flecha e depois diz “fale”. E execute nosso código. Você pode ver que um animal fixo soa um animal, pouco de latido, o que faz sentido a partir de agora. Mas mesmo que nosso gato aqui tivesse uma implementação de falar. Então, vamos colocar isso de volta na nossa aula de gatos aqui e mudar para miau. Então, se executarmos nosso código novamente, você verá que obtemos um resultado estranho. E isso porque nosso ponteiro aqui, que os acessos falam, na verdade fará referência à versão da classe base. Enquanto isso aqui embaixo, onde usamos nossos objetos de gato especificamente, usaremos a classe derivada ou nossa versão de classe infantil, e isso pode nem sempre ser o que você deseja. Então, vamos dar uma olhada em uma maneira de consertá-los. Então, se formos até nossa classe base aqui, sendo animais e formos para nossa função de fala aqui. O que vamos fazer é colocar a palavra-chave virtual na frente dela. E só precisamos fazer isso na declaração. E o que essa palavra-chave virtual faz aqui é basicamente dizer explicitamente que queremos que as subclasses de nossa classe animal tenham sua própria implementação dessa função. E ainda podemos deixar nossa implementação básica aqui. No entanto, estamos deixando nosso programa agora aqui. Ei, queremos que cada classe que deriva do animal tenha sua própria implementação dessa função, é por isso que a tornamos uma função virtual. Então é isso que isso faz, é apenas dizer explicitamente: Ei, queremos que subclasses de nossa superclasse ou classes infantis de nossa classe principal criem suas próprias versões dessa função. Então, agora, se executarmos nosso código, você pode ver que agora ele imprime miau e nosso ponteiro aqui. E então, como referência, nossa função de fala agora funciona com a reversão de subclasses dela. E isso porque dissemos explicitamente: Ei, queremos que nossas subclasses tenham sua própria implementação dessa função. E eu não vou entrar no âmago da razão pela qual isso funciona dessa maneira. Mas saiba que se você planeja ter uma função na classe base que seja sobrescrita e em suas subclasses, você desejará adicionar a palavra-chave virtual. E lembre-se de tudo o que tivemos para lidar com o ritual na declaração e em nossa classe base, mas não na definição aqui embaixo. Só para mostrar isso rápido, o FOR cat, por exemplo, não tinha sua própria implementação. Isso ainda funcionaria muito bem. Ok, então não o obriga, mas ainda temos um problema no caso de querermos que nossa classe base não tivesse sua própria implementação. E queríamos forçar cada subclasse a ter sua própria implementação e não ter que nos preocupar com o fato de esquecermos dela. Isso simplesmente não vai funcionar. Isso pode nem sempre ser o caso. Em algumas circunstâncias, talvez você queira que a classe base tenha sua própria implementação, como fizemos aqui. Mas no caso de você não ter, deixe-me mostrar como podemos resolver isso. Então, em vez de ter apenas uma função virtual aqui, podemos realmente criar uma função virtual pura. Então, deixe-me mostrar como isso é feito. Primeiramente, vamos remover a definição de velocidade de forma totalmente religiosa para nos livrarmos dela. Então, aqui em nossa declaração, diremos depois dos parênteses fechados, mas antes do ponto e vírgula, diremos que é igual a 0. E agora isso é uma função puramente virtual. E agora que vimos uma função puramente virtual em uma função virtual normal, há apenas algumas coisas que eu quero que você tenha em mente. Primeiramente, as funções rituais não podem ser estáticas, ok, então essa não pode ser a única versão dessa função porque você está dizendo, Ei, eu quero que minhas subclasses tenham sua própria versão dela, ok, então portanto, isso não faz nenhum sentido. Além disso, uma função virtual pode ser uma função de amizade de outra classe, e abordaremos as funções e aulas de amizade em um próximo vídeo. Só algo para anotar. Não se preocupe com isso agora. Então, o que é uma função puramente virtual? Bem, podemos dizer que queremos defini-lo como igual a 0. Estamos dizendo que essa função não tem definição. Pode muito bem não existir. Portanto, cada subclasse precisa ter sua própria versão. E você pode estar se perguntando, por que não nos livramos de um vazio, falamos aqui inteiramente e simplesmente o jogamos em todas as subclasses, como nosso cachorro, gato. Se criássemos outro, como um laço ou cavalo, etc. Bem, poderíamos esquecer um deles, e então todo animal pode não ter uma função de falar. Além disso, por exemplo, se criássemos um método ou uma função que considerasse o animal como perímetro, não poderíamos usar a função speak, pois nossa função não sabe mais se todo animal pode falar, porque isso não está definido dentro da classe animal, certo? Então é por isso que você gostaria de ter isso aqui em primeiro lugar. Então, como eu disse, ele apenas remove o cabelo humano. Então, agora, se formos para nossa classe de cães, já temos uma implementação da lista. No entanto, nossa classe de gatos não. E, como você pode ver, isso imediatamente nos dá um erro. Esse é um objeto de um tipo de classe abstrata. O gato não é permitido porque existe uma função virtual pura. Agora, uma classe abstrata é uma classe da qual você não pode criar um objeto diretamente. Então, não podemos mais dizer o animal. Meu curso, por exemplo, e dê a ele um nome como Jack. E uma idade. Isso não funcionará porque é uma classe abstrata. E a razão pela qual é abstrato é porque há uma função dentro dela que não tem definição. Basicamente, não existe e as subclasses precisam criar a definição para isso. Portanto, não podemos criar objetos nela em uma classe abstrata é qualquer classe que tenha uma função virtual pura. Como essa função não tem uma definição real , não podemos criar um objeto dessa classe porque agora ela tem uma função que não está definida. Tudo bem? Então, ter uma função puramente virtual para dar credibilidade à aula, que já estamos meio mortos por ter nosso construtor de animais protegido. Mas mesmo que isso fosse público, ainda não seria criável apenas por causa de nossa função puramente virtual aqui, agora é considerada abstrata em uma coisa a ser observada, para aqueles de vocês que vêm de outras linguagens de programação, especialmente para vocês, bem como se cada membro da turma for puramente virtual e não tiver nenhuma implementação de nada por si só. Essa classe agora é considerada uma interface para outras coisas porque não tem definição de nada. São só declarações. Portanto, o que é chamado de interface é essencialmente apenas um modelo para qualquer coisa. E Haritsa com uma função virtual pura, é uma classe abstrata. E se tudo e fosse puramente virtual, seria uma interface, fosse considerado uma interface de qualquer maneira, como você viu, porque temos essa função puramente virtual, não há espaço para erro humano ao criar animais diferentes. Então, quando criamos nosso cachorro aqui, dissemos como um animal ou nosso gato que era um animal, etc. Todo animal que criamos agora terá que ter uma versão da função de falar, certo? Porque não há definição por si só. E tecnicamente você poderia deixar assim. E isso agora é considerado essencialmente uma classe abstrata porque tem uma função sem definição. E então você pode ter uma classe que deriva do gato ou herda do gato. E, eventualmente, um deles precisaria ter uma definição para falar, porque você não pode ter um objeto de uma classe que tenha uma função ou método puramente virtual porque não nos permitirá fazer isso agora, alto-falantes agora implementados corretamente. Então ele disse, todo animal tem que falar e ter sua própria maneira de falar. Então, aqui em nossa classe, vamos seguir em frente e colar nosso método de fala. E só para fazer as coisas corretamente, vamos resolver isso agora. Então, diremos que o vazio fala, ponto e vírgula, exatamente assim. E copiará esse envelope, uma aula de cães, por exemplo aqui. Então, para as palavras bico, diremos cachorro, cólon, cólon, fala, e ali até ponto e vírgula, exatamente assim. E livre-se da nossa definição aqui, assim como fizemos com todas as nossas outras funções, como eu disse antes, e essa é a maneira correta de fazer isso. Então, copiaremos isso novamente, ponto e vírgula no final para criar a declaração. Corte isso e coloque a definição abaixo. E, na verdade, vou colocá-lo abaixo do nosso construtor aqui. Isso será a erosão da fala dos gatos. E, a propósito, caso eu tenha esquecido de mencionar isso antes, em nossos construtores aqui, onde tínhamos nosso construtor de animais, aqui está o construtor da classe base. Isso precisa ocorrer primeiro antes que qualquer outra coisa em nossa lista o inicialize aqui. Mas, como eu disse, tudo no inicializador da lista precisa ser uma ordem de cima para baixo, e um construtor de classe base precisa estar em primeiro lugar. Então, só queria te avisar sobre isso, caso seja algo que eu esqueci de mencionar. E então aqui em nossa definição de maiúsculas para velocidade, vamos alterá-la para executar nosso código. Pronto, tudo está funcionando corretamente. Agora, nosso ponteiro animal, que está apontando para o nosso gato, está usando a versão correta dele. E poderíamos até mudar nosso ponteiro para o meu cachorro, e tudo isso funcionaria muito bem. Além disso, agora não é possível criar um novo animal ou uma subclasse de animal que não tenha sua própria versão de falar. Tudo bem, então isso é fantástico. Tudo está funcionando. E esse foi o último exemplo de polimorfismo que vamos analisar, pois agora nossa função de fala tem várias versões, certo? Lembre-se de que polimorfismo significa que assumir muitas formas, por assim dizer, não é apenas um ritual puro, uma função sem definição, mas tem sua própria versão dentro de nossa classe de cães e tem sua própria versão dentro de sua classe de gatos. Então, há alguns exemplos de polimorfismo para você. Tudo bem? Aprendemos o que é uma função virtual, que é apenas uma função que você disse explicitamente que escolheu as subclasses para ter sua própria versão dela. Também demos uma olhada em como criar uma função puramente virtual, que foi criada definindo essa função igual a 0, basicamente dizendo que é igual a nada. Não existe agora. E remova a definição que não apenas torna a classe abstrata automaticamente, mas se tudo fosse puramente virtual na classe, seria o que é chamado interface é basicamente um modelo para tudo o que herda dela em uma função puramente virtual em comparação com uma função virtual normal, que teria essa aparência, é apenas uma função que agora precisa uma definição para ser criado dentro de uma classe que deriva dela. E se nossa classe de cães não tivesse sua versão , também não poderíamos criar um cachorro. Ela precisa de uma definição em algum momento. Então, teríamos que ter raças de cães como classes ou algo assim e dar uma definição a elas. Em algum momento, ele precisa de uma definição para você criar objetos de qualquer classe que deriva de animal, certo? Também aprendemos que toda subclasse ou classe infantil também é considerada uma classe base, mas nem toda classe de pais é uma classe infantil. E apenas um lembrete em nosso exemplo, é basicamente como dizer que todo cachorro é um animal, mas nem todo animal é um cachorro. E só para mostrar rapidamente outra maneira poderíamos, tenho um exemplo disso. Podemos ter criado uma função como essa, dizendo animal vazio ou algo parecido. E então como parâmetro, porque eles podem ser um animal e um animal. Dentro daqui, poderíamos ter dito animal, morrer, falar. Como você pode ver, temos um erro. E isso é só porque o animal é atualmente uma classe abstrata. Então, vamos corrigir isso rapidamente aqui e mudar isso de uma função puramente virtual para apenas uma função virtual normal. E daremos uma definição rápida como essa, assim mesmo. Agora, se formos até aqui, deixe-me dizer falta de voz e paixão, seja nosso gato ou cachorro. Então, vamos comprar um gato apaixonado. E, como você pode ver, quando executamos nosso código e, na verdade, ele não imprime nada depois do latido. E isso porque isso realmente usou a versão animal dessa função, já que criamos uma cópia dos valores dos gatos e a colocamos essencialmente em um animal. Mas para corrigir isso, tudo o que precisamos fazer é fazer uma referência ao animal Peston, e agora isso funcionará muito bem. Então, se executarmos nosso código novamente, pronto. Ele o imprime. Sim. E como eu disse, um cachorro também é um animal, também poderíamos ter passado pelo meu cachorro. E nosso código e nossa função teriam funcionado da mesma forma, exceto que agora ele imprime a casca. Então aí está. Então aí está. Espero que agora você tenha uma compreensão básica do polimorfismo em algumas das diferentes maneiras de usá-lo, junto com algumas palavras-chave diferentes que o acompanham. Então, analisamos classes e interfaces abstratas. Também analisamos a criação de funções virtuais que têm sua própria implementação e dizemos isso explicitamente dessa forma. Quais subclasses criar suas próprias versões disso em funções puramente virtuais, que basicamente dizem que não há definição e as subclasses precisam criar sua própria versão dela. E as subclasses, nossas classes base, essas classes base não são necessariamente subclasses. Então, não poderíamos ter pegado um gato como parâmetro e enviado um animal para eles. De qualquer forma, isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 96. Capítulo 15 (aulas): quatro princípios principais do OOP: Neste vídeo, vamos revisitar os quatro pilares ou princípios principais da programação orientada a objetos. E eles não estão em uma ordem específica. E também outra observação é que não abordamos todos os aspectos possíveis de cada um desses quatro pilares principais, mas abordamos o básico e a essência principal deles divididos, você sabe o que são e como e quando você pode implementá-los em seus próprios programas. Então, a primeira é que vamos falar sobre poluição. E, se você se lembrar, encapsulamento ocorre quando os dados são ocultados do exterior ao serem encapsulados em funções acessíveis. Então, um exemplo de quando fizemos isso, foi quando tivemos nossas funções getter e setter que ajudam todas as nossas variáveis privadas dentro delas são variáveis privadas encapsuladas em nosso getter e funções de ajuste. Tudo bem, então esse é o nosso primeiro. Em seguida, falaremos sobre abstração. E, basicamente, você pode pensar nisso como quase uma extensão do encapsulamento e abstração quando você mostra apenas dados ou informações relevantes ao usuário. Por exemplo, ao ligar telefone ou abrir um aplicativo, você só vê as informações relevantes. E um exemplo de quando fizemos isso é mais uma vez, quando tivemos nosso getter e setter, você não precisava saber o que estava naquele bloco de código, como exatamente isso afetava nossas variáveis privadas. Tudo o que você precisa saber qual é o nome da função e os parâmetros. Todo o resto acabou de acontecer em segundo plano. Por exemplo, quando tínhamos nossa variável de saúde e ela não permitia que você passasse de 100 ou abaixo de 0. O usuário não precisava saber nada disso. Quando chamamos o peão de nossas funções para alterar ou definir nossa variável de saúde, precisamos apenas indicar o nome da função e o que a inserção como perímetro e tudo mais foi abstraído. de nós. Estava escondido no fundo. Então isso foi abstração. Em seguida, temos a herança como basicamente quando algo herda de outra coisa. Então, por exemplo, na programação, herança é quando você herda membros de outra coisa, isso permite que você encontre semelhanças em uma classe principal. Então, por exemplo, nossa classe animal, que meio que definiu o que é um animal, pudemos ter coisas como uma função de fala, uma variável de saúde chamada variável. Conseguimos estabelecer a base para o que era um animal. E então as coisas que podemos herdar disso para meio que ficar, ei, isso é um animal. Então, ele terá tudo o que todos os animais têm. E então também pode ter sua própria identidade, sua própria singularidade. Então, por exemplo, nossos animais para cães e gatos imprimiram coisas diferentes. Então, quando nosso gato falou e quando o escuro falava, e quando foi criado, ele imprimiu coisas ligeiramente diferentes, dizendo ou um catalisador criado ou um cachorro que foi criado especificamente. Mas todos eles tinham uma coisa em comum a classe dos pais ou a classe animal que criamos, certo? E esse foi um exemplo de ter duas classes herdadas de uma classe base. E lembre-se de que há muitas outras coisas que você pode ver chamadas de aulas para crianças e pais, mas muitas vezes as aulas de pais e filhos são usadas com mais frequência. E é apenas uma maneira fácil de pensar sobre isso. Porque, por exemplo, os filhos herdam coisas dos pais. Então, essas são conexões fáceis da vida real ali mesmo. E, por fim, temos o polimorfismo. E o que significa polimorfismo é assumir várias formas. E acabamos de ver alguns exemplos disso no último vídeo. Então, alguns exemplos de quando usamos polimorfismo são funções primordiais. Além disso, usamos subclasses como classe base. Por exemplo, usamos um gato e um cachorro como substitutos do perímetro de um animal porque sabemos que qualquer coisa e animal podem fazer. Um gato e um cachorro também podem fazer isso porque herdam todos os mesmos membros e muito mais. E então alguns outros exemplos disso que analisamos onde nossas funções virtuais e virtuais puras, que explicitamente diziam: Ei, se elas forem sobrescritas e haverá outras implementações dessa função. De qualquer forma, aí está. Esses são os quatro princípios ou pilares principais, em vez de uma coluna de programação orientada a objetos. Então você tem encapsulamento, abstração, herança e polimorfismo. Eu sei que muitos cursos para iniciantes não abordam todos esses quatro. Mas, pessoalmente, vejo que esses são os quatro princípios principais da programação orientada a objetos. Eu simplesmente não consigo ver deixá-los de fora de nenhum curso para iniciantes, especialmente porque muitas vezes, depois de terminar um curso para iniciantes em programação, você vai sair e começar a trabalhar com seus próprios programas e apenas tentando fazer o máximo puder com o que você sabe e como você vai criar código de boa qualidade em uma linguagem de programação orientada a objetos se você nem sabe os quatro princípios principais da programação orientada a objetos, qualquer forma, espero que você tenha gostado do vídeo como sempre, obrigado por assistir, e nos vemos no próximo. 97. Capítulo 15 (aulas): funções e aulas de amigos: Neste vídeo, falaremos sobre as funções e classes do Friend no C plus plus. Em primeiro lugar, vou te contar o que é uma função de amigos e uma aula de amigos. Vou dar uma olhada e criar um exemplo de ambos. Uma função de amizade é uma função que pode acessar os dados privados e protegidos de uma classe. E uma turma de amigos pode acessar dados privados e protegidos ou membros de outra turma. De qualquer forma, vamos criar e dar uma olhada em um exemplo de uma função de amizade e de uma aula de amigos. Tudo bem, então acima da nossa função principal, vamos criar uma classe, e vamos chamar essa classe. Teremos nosso bloco de código assim. E não se esqueça do ponto e vírgula no final. Agora foo geralmente é um nome genérico que você verá com bastante frequência em exemplos. É apenas um nome comum de ocupante de lugares. Então, vamos usar isso apenas para mostrar um exemplo do que você pode ver isso como. No momento, estou mostrando um exemplo de algo. Eu vou dizer classe. E aqui dentro com uma variável bem alta. Então, vamos dizer privado, assim mesmo. E então Dumbo isso. Vamos apenas dizer int x e na verdade, vamos inicializar isso. Eu sei que normalmente você quer ter isso separado, mas só para manter esse exemplo direto, não vamos nos preocupar com isso. E então, fora da classe, criaremos uma função que imprime x. Então, digamos void, print x. E, entre parênteses, teremos um parâmetro que usa um objeto da classe Foo. Então salve, e vamos chamar isso de minúsculas lá. Então, dentro do nosso bloco de código, dirá foo got x. Agora, como sabemos, variáveis privadas e protegidas não estão acessíveis fora da classe. E as funções de amizade, assim como as classes de amigos, não são membros da classe da qual são amigas, nem são subclasses dela, elas são completamente separadas. No entanto, para declarar nossa função como uma função amiga, precisamos especificar isso dentro da própria classe. Então, em nossa classe Foo aqui, basicamente teremos o que seria uma declaração ou um protótipo da nossa função print x. Então, vamos simplesmente copiar essa linha inteira e colá-la aqui. Não esqueça nosso ponto e vírgula aqui no final. Agora, como você pode ver, em um ainda inacessível, para corrigir isso, tudo o que você precisa fazer é tornar essa função de amigo adicionando a palavra-chave amigo antes de um vazio aqui, assim mesmo. E agora, como você pode ver, isso funciona muito bem. Então, se formos até nossa função principal e simplesmente invocarmos nossa função print x, imprimirmos x e y. Eu tenho que inserir e implementar foo aqui. Então, vamos chamá-lo. Então, vamos enviar isso. Aqui mesmo. Lá vamos nós. Conseguimos acessar esse membro privado com nossa função de amigo. E observe que só precisávamos colocar Friend e essa linha aqui e não a declaração real da função lá. A propósito, uma função de amizade pode ter vários amigos. Então, para mostrar isso, vamos remover tudo. Você não acha? Lembre-se de nossa função e nossa declaração de função de amigo. Então, vamos mudar a classe foo para class, copiá-la e colá-la abaixo. E vamos chamar essa classe a, classe B, um número inteiro privado. Vamos chamar isso de y, só pra caramba. E vamos definir isso como igual a dez. Em seguida, abaixo, criaremos nossa função, digamos void, e então a classe paga um objeto e chamaremos essa classe de objeto de be e a chamaremos de b. Então faremos dela uma amiga de ambas as classes. Então, basta copiar essa linha superior aqui, colá-la, colocar um ponto e vírgula no final e adicionar a palavra-chave. Então, podemos simplesmente copiar isso e colar, assim. E então, dentro da nossa função aqui, a x mais b y, exatamente assim. Agora observe que este está inacessível, e eu vou te mostrar o porquê em apenas um momento. Mas antes de fazer isso em nossa função principal, criaremos uma instância de ambos os glosses. E lembre-se de que podemos nomear isso como você quiser. Isso não importa. Nossos nomes de perímetro serão separados. Então, eu poderia dizer um b e uma pequena função de adição de cor. Como não faz parte de nada. Não precisamos especificar de onde vem. E então diga, não coloque um ponto e vírgula no final. E isso funcionaria bem se corrigíssemos esse erro aqui. A razão pela qual estamos entendendo isso é porque a classe não sabe o que é classe B quando lê nosso código aqui. E podemos corrigir isso com algo chamado declaração direta. E vamos colocar isso aqui no canto superior direito acima da nossa classe A. E tudo o que vamos fazer como classe e colocar um ponto e vírgula no final. E isso vai resolver tudo. E como eu disse, isso é chamado de declaração direta. Vimos exemplos disso quando tínhamos um protótipo de função e depois a definição abaixo, exceto que isso estava fazendo a mesma coisa com uma classe. Estamos basicamente dizendo, ei, será uma classe chamada código B e R e agora uma classe não confundiu. Como você pode ver, o erro desapareceu e podemos executar nosso código, imprimir 15 porque nossa função de adição e acesso à variável privada x e à variável privada y. Podemos chamá-las de X. Realmente não teria importado. Então aí está. Há alguns exemplos de funções de amizade, que são apenas funções que têm acesso a membros privados e protegidos da classe ou classes das quais são amigos. E depois temos aulas para amigos. Eu vou te mostrar isso agora. E para fazer isso, vamos para a classe I, e vamos simplesmente remover nossa função de amizade aqui por completo, assim. E então vamos dizer aula de amigos, sem mais nem menos. E agora a classe B tem acesso aos membros privados e protegidos da classe. E vamos seguir em frente e remover completamente nossa função de amizade agora. E vamos movê-lo para cá em nossa função principal. E então, na classe B aqui, criaremos uma função para adicionar x e y. Então, diga void add i. Agora, normalmente, não gostaríamos de colocar a definição dentro da classe aqui. Mas para manter as coisas simples, vamos seguir em frente e fazer isso. Então aqui vamos dizer uma cor. Eu vou dizer y mais x. E porque a Classe B era amiga, digamos, como afirmado aqui. E mais uma vez, uma turma pode ter vários amigos, assim como suas funções. Ele terá acesso a variáveis privadas dentro da classe, bem como protegidas, mesmo que não seja uma subclasse da classe a ou faça parte da classe a. Então, criamos uma instância de classe, digamos, dentro da classe B, assim como fizemos com nossa função de amigo, basicamente, pois ainda precisávamos de uma instância da classe para trabalhar. E agora, em nossa função principal, podemos nos livrar de tudo isso aqui e apenas dizer B e chamá-lo de B ou o que você quiser. E então, lá embaixo, seria assim com o ponto e vírgula no final. Você precisa fazer isso para corrigir esse erro aqui em que estamos inacessível, é tornar nossa função opinião pública, pública. Vou limpar isso um pouco e vamos lá. Nossa função agora está acessível por nossa instância da classe, pois ela é pública e podemos prosseguir e acessá-la. E aí está. Sai 15 porque y e cinco se somaram porque a equipe, de qualquer forma, aí está. Agora você sabe o que um amigo funciona e as aulas de um amigo e como usá-las. Então, como sempre, obrigado por assistir e nos vemos na próxima. 98. Capítulo 15 (aulas): namespaces: Neste vídeo, falaremos sobre espaços para nomes. Agora, como alguns de vocês devem se lembrar, parte do nosso código vem do namespace padrão, como C e C out. E a razão pela qual não tivemos que fazer muito com isso foi porque especificamos ou dissemos explicitamente que usaremos o código do namespace std. No entanto, se isso não estivesse aqui, vou continuar comentando isso por um minuto e tentaremos dizer que algo está vinculado a C out. Não tem ideia de onde vem o SEO. E isso porque faz parte do namespace padrão std aqui, para abreviar. Se não quiséssemos ter isso explicitamente no topo, teríamos que dizer std dois pontos, dois pontos seguidos por C out, ou o pedaço de código que estamos usando desse namespace e CN contínuo aqui embaixo. E algumas das outras coisas que usamos no passado também. Number a namespace é basicamente apenas um espaço nomeado ou uma parte nomeada do código para ajudar a especificar do que você está falando. Então, normalmente, se você tivesse duas funções com o mesmo nome exato e os mesmos parâmetros, seria difícil distinguir qual delas você está usando. No entanto, se cada um fizesse parte de seu próprio namespace , nosso compilador saberá de qual deles estamos falando e se referindo à origem do código. E um exemplo que usei em um vídeo anterior, pois você pode pensar nisso como o sobrenome de alguém. Então, se eu fosse até você e começasse uma conversa e eu dissesse , John, talvez você não soubesse de quem eu estava falando. Mas se eu dissesse como John Silver ou algo parecido, então porque eu associei isso a um sobrenome, você saberia de quem eu estava falando daqui em diante. E isso é meio parecido com o fato de dizermos que vamos falar sobre o código do nosso namespace padrão em nosso código aqui. Tudo bem, então de qualquer forma, se isso não estava aqui, observe que temos que especificar onde esse código está vindo. Ao criar programas maiores você mesmo, talvez queira criar seus próprios namespaces para ajudar a diferenciar de onde vem seu código. E eu vou te mostrar como podemos fazer isso agora. Então, deixe-me ir em frente e remover essas coisas aqui. Na verdade, tenho a sintaxe para criar seu próprio namespace aqui. Então, você terá a palavra-chave namespace seguida pelo nome do seu espaço de nome. E então, dentro dos colchetes, você terá o código que não faz parte dele aqui em cima. Vamos seguir em frente e criar duas funções. E esse será um exemplo bem básico, mas eu deveria entender como criar e usar um espaço nomeado ou um namespace. Então, diremos vazio. Imprima olá. Dentro do código para isso. Vou apenas dizer escala. Olá. Só para ajudar a diferenciá-los , porque vamos criar outra função com exatamente o mesmo nome, o mesmo namespace Hello. Um. Assim mesmo. Em seguida, criaremos uma linha em branco. Então, vamos copiar tudo isso e colar abaixo. E vamos mudar essa para dizer, quero dizer, ela tem dois anos. E atualmente, se tentássemos chamar essa função enviando olá e executando nosso código. Você pode ver que vamos receber um erro. Isso porque a função que tem um tipo de retorno vazio chamado print hello e não tem parâmetros já existe. Portanto, não podemos ter duas da mesma coisa. E à medida que seu código se expande o máximo possível , você terá o mesmo problema em que poderá ter várias funções o mesmo nome apenas devido à sua legibilidade ou algo parecido. E esse é um ótimo exemplo de quando você gostaria de criar um namespace. Aqui em cima, vamos dizer namespace. Chame esse namespace de um só por simplicidade. Então teremos nossos colchetes encaracolados abertos e fechados , assim. Em seguida, vamos cortar essa função superior aqui e colá-la dentro, assim mesmo. Em seguida, copiaremos tudo isso e colaremos abaixo. E vamos seguir em frente e nos livrar dessa função extra e n aqui. Vamos apenas mudar isso para o namespace Hello para. E agora, como você pode ver, ele não sabe nada do que estamos falando. E diz que imprimir olá é completamente indefinido. E isso porque, assim como com nossos objetos CN ou C, não temos ideia do que estamos falando e, na verdade, mudaremos isso, o namespace para aqui embaixo também. Portanto, temos que informá-lo de onde essa função de impressão de saudação. E poderíamos fazer a mesma coisa que poderíamos com nosso namespace std aqui, onde acabamos de colocá-lo logo antes. Então, podemos dizer namespace, dois pontos, dois pontos, assim, imprimir olá. Então, se copiarmos toda essa linha e colarmos abaixo, dessa forma, change lista o namespace e executamos um código. Você pode ver que ele funciona muito bem e sabe exatamente qual deles queremos usar porque especificamos de onde vem esse código. Agora, neste exemplo, usamos apenas uma função básica, mas você precisa ter todos os tipos de código em um namespace. E lembre-se de que um namespace nos permite separar nosso código e ser mais específicos sobre a origem desse código, a fim de ajudar a evitar conflitos e nomenclaturas. Então, por exemplo, aqui temos duas funções com o mesmo nome, porque elas fazem parte de um namespace diferente, podemos especificar de onde isso vem e esses nomes não entrarão em conflito algum. . Agora, assim como antes, quando dissemos que estamos usando o namespace std. Aqui em cima. Podemos dizer algo como usá-los. Namespace, namespace. E não se esqueça do ponto e vírgula no final disso. E agora, se eu quisesse, eu poderia simplesmente me livrar de dizer namespace 1 e executar nosso código aqui. E isso funcionará muito bem porque eu já especifiquei que vou usar o código desse namespace. Agora você deve estar se perguntando se fizéssemos a mesma coisa com namespace para executar nosso código novamente? Bem, como você pode ver, tivemos um erro e isso porque, mais uma vez, ele não sabe do que estamos falando aqui. No entanto, observe que não recebemos um erro aqui embaixo. E isso porque temos dois namespaces que dissemos que vamos usar. E há um conflito na nomenclatura dessas duas funções, certo? Porque temos duas funções com o mesmo nome em dois namespaces diferentes que dissemos que estamos usando. Agora. Outro código dentro desses namespaces que não tinha um conflito no nome ou o nome não era o mesmo. Não teríamos um erro. Poderemos usar os dois separadamente sem problemas. Então, por exemplo, se simplesmente copiarmos essa função aqui e colarmos abaixo dela e fizermos o mesmo aqui em cima. Vamos ligar para este até este. E este aqui embaixo, imprima olá para, bem, eu posso dizer imprima olá um, assim mesmo. E ele vai saber do que estou falando porque agora há apenas uma função com esse nome em qualquer um dos namespaces que dissemos que estamos usando em nosso código em geral. Agora, vai funcionar muito bem. Posso ponderá-los para mudar isso aqui. Então vá em frente e faça isso. E se eu executá-lo novamente, você pode ver que ele imprime o namespace 1, porque é daí que esse código estava vindo. Então, se você estiver usando vários namespaces e tiver dito isso explicitamente no topo aqui. E você tem uma função que tem o mesmo nome de outra função, seja em seu código ou dentro de um dos namespaces aqui, você precisa especificar de onde ela vem, como fizemos aqui. Então, imprima olá para, poderíamos usar normalmente e imprimir olá um que poderíamos usar normalmente. No entanto, imprima olá agora, porque temos dois deles com o mesmo nome, só precisa ser especificado. Então, assim como fizemos aqui embaixo, aqui em cima, o namespace, um, dois pontos, dois pontos, assim, executa nosso código. Como você pode ver, tudo funciona bem. Então aí está. É assim que você cria um namespace. Simplesmente vou dizer namespace seguido por um nome e, em seguida, um conjunto de colchetes com seu código dentro dele. Então, se você quiser usar o código desse namespace, você pode simplesmente fazê-lo explicitamente assim ou dizer explicitamente seu código na parte superior. Ei, vou usar a codificação desse namespace. E isso só vai te ajudar a ordenar seu código para que você saiba exatamente de onde ele vem, bem como evitar conflitos nomes com funções, variáveis, etc. Então aí está. De qualquer forma, obrigado por assistir, e nos vemos na próxima. 99. Capítulo 15 (aulas): matrizes de objetos: Neste vídeo, falaremos sobre a criação de matrizes de classes e veremos como podemos trabalhar com isso também. Então, primeiro, no topo, vamos criar uma nova classe. E vamos dizer algo como aula. Item. Dentro do nosso código aqui, diremos algo assim. Vamos dizer fio, nome e depois ouro, assim. E vamos seguir em frente e tornar essas duas variáveis privadas. E lembre-se de que isso foi feito por padrão. Mas vamos seguir em frente e tê-lo. Eles são explicitamente porque, acima de nós, vamos criar alguns métodos públicos com os quais trabalhar. Então, diremos público, assim. E então criaremos duas funções, criaremos uma chamada item. E isso não exigiria nenhum parâmetro e também não teria um tipo de retorno. Então, vamos apenas dizer item vazio. Então, para isso, diremos vazio. E também não teremos nenhum perímetro para isso. Então, nossa turma agora é exatamente assim. E então criaremos as definições para essas duas funções na classe baixa. Então, vou copiar isso aqui, colar isso e copiar e colar isso também. Então, precisamos dizer explicitamente de onde eles vêm. Então, nome da réplica, diremos o item dois pontos, dois pontos, exatamente assim. E faremos o mesmo aqui embaixo. Em seguida, precisamos dos colchetes para a definição de cada método. Então, dentro do item definido, vamos continuar assim. Vamos dizer CL, nome do item, espaço de dois pontos exatamente como aquele ali. E, abaixo disso, o que eles veem. E depois disso, criamos uma linha em branco, assim. Em seguida, imprimiremos o espaço de custo do item. E colocaremos um ponto e vírgula no final disso também. E então diremos C e continuaremos assim. E então, aqui embaixo, vamos imprimir essas duas variáveis. Então, diremos o nome CL, seguido por um espaço. Espaço. Vamos acompanhar os custos da Coca-Cola. Então, entre aspas, diremos peças de ouro espacial e colocaremos um ponto e vírgula no final. E, na verdade, ele também criará uma nova linha no final disso. Faça você mesmo, tudo bem, então certifique-se de que toda a sua classe corresponda à minha aqui. E abaixo em nossa função principal, diremos que o tamanho de const int é igual a três. Em seguida, abaixo, isso criará um loop for. Então, digamos que para int I é igual a 0, I menor que o tamanho I mais, mais. Então, vamos copiar isso e colar abaixo. Mas agora temos 24 loops. Vamos passar por aqui três vezes. E então, abaixo de uma constante aqui, criaremos uma matriz de itens do tipo. Item, vou chamar isso de itens. Em seguida, n colchetes. Vamos dizer tamanho. O que significa colocar um ponto e vírgula no final desse jeito? Então, em nosso primeiro loop for, vamos dizer item no índice i. Já que ele vai de 0 a dois, que é o mesmo índice da nossa matriz de itens atualmente, porque esse é um tamanho de três. E depois de fechar o colchete aqui vamos simplesmente dizer ponto, definir item, abrir e fechar parênteses e um ponto e vírgula no final. Então, toda vez que ele passa pelo nosso loop for aqui, ele percorrerá os diferentes itens em nossa matriz de itens do tipo e executará esse código aqui a partir de nossa função set item. Vamos apenas pedir o nome do item e, em seguida, inserir um nome, e então eu pedirei um item, ouro custa, e nós o inseriremos também. Então, em nosso segundo loop for, diremos itens no índice I, item de impressão. Então, vamos adicionar um pouco de texto de contexto em cada um deles para loops, certo? Então, vamos dizer espaço do item e imprimir I mais um. E eu vou continuar com o espaço. Etapas. Vou dizer dois pontos e depois criar uma nova linha. Então, vamos dizer barra invertida n. Ok, então agora vai funcionar muito bem. Copie isso e cole em nosso outro for-loop também. Então, se voltarmos ao nosso item definido aqui, vamos remover esse extra e o meu enviado. Já vai cair uma linha depois de colocarmos o nome aqui. Tudo bem, então vamos seguir em frente e executar nosso código. E como você pode ver, isso é para o item sobre estatísticas. E eu vou chamar isso de maçã. Dê a ele um item de custo de ouro para chamá-lo de laranja. Custo de três. E, por fim, direi algo como coco e considero um custo de cinco. E depois, você pode ver que imprimimos as estatísticas de cada item. Então, eu não queria Stats. A Apple custa para peças de ouro, item para estatísticas, colunas laranja, três, item por estatísticas, coco causa cinco e eles vão. É assim que você pode trabalhar com uma variedade de objetos. Você criará uma matriz normal com o tipo sendo o nome da classe assim, como o tipo com o qual queremos trabalhar , o nome da matriz, como de costume, e seu tamanho como normal. E então, tudo o que você precisa fazer é usar seu operador de acesso de membros para trabalhar com os membros disponíveis de cada classe. A propósito, se você estiver trabalhando com uma coleção do tipo de classe base e, em seguida, inserir itens de um tipo de subclasse. Então, por exemplo, se tivéssemos um vetor de animais antes e depois inserirmos objetos de gato e cachorro. Você vai querer trabalhar com uma matriz real de ponteiros para esses objetos e não para os objetos e células. E isso porque cada subclasse terá tamanho e memória variados. Já se você tivesse apenas um ponteiro para cada um desses objetos de subclasse em seu contêiner, todos os ponteiros ocuparão a mesma quantidade de memória e você não terá problemas. Então, como eu disse, se você estiver trabalhando com o contêiner de um tipo de classe base e teremos itens de seus tipos de subclasse. Como isso funcionará, certifique-se de trabalhar com uma série de ponteiros para esses objetos, e não apenas para esses objetos em si. Dessa forma, todos eles ocupam a mesma quantidade de memória e você não tem problemas. Enfim. Isso é tudo para este vídeo. Obrigado por assistir, e nos vemos na próxima. 100. Capítulo 15 (aulas): separação de arquivos: Neste vídeo, mostrarei como você pode separar suas aulas em arquivos separados. Um é um arquivo de cabeçalho e o outro é um arquivo CPP, que, se você olhar para o topo aqui, é o que temos trabalhado com esse tempo todo. E isso inclui declarações com as quais estamos trabalhando, que também nos permitem acessar arquivos de cabeçalho de outras classes. E mostrarei como podemos acessar ou incluir nossos próprios arquivos de classe. E isso realmente permitirá que você organize seu código e o use em vários programas, pois você poderá simplesmente acessar o arquivo que ele não é. Então, vamos começar. Primeiramente, aqui no topo, vamos dizer classe. E vamos chamar isso de minha turma. E então, dentro daqui, vamos apenas criar uma função básica. Então, vamos dizer vazio, imprimir, abrir e fechar parênteses e um ponto e vírgula no final. E então vamos definir essa função fora da nossa classe. Porque, se você se lembrar, essa é a maneira correta definir funções para suas classes. Então, digamos, menino na minha classe, dois pontos, dois pontos ou o operador de resolução de escopo, seguido de trabalhar parênteses abertos e fechados. E então teremos nosso bloco de código abaixo. E dentro daqui, vamos dizer que o CL está funcionando exatamente assim. E aí está. Vamos ver como podemos dividir isso agora em vários arquivos corretamente. Agora, só para adicionar alguns comentários aqui. Então, sua declaração de classe vai entrar em algo chamado arquivo de cabeçalho. Tudo bem, então isso aqui vai entrar em um arquivo de cabeçalho. E então suas definições para tudo o que você declarou entrarão no arquivo cpp. Certo? Então, vamos em frente e fazer isso. Então aqui embaixo em nossa função principal, vamos em frente e também imprimir. Antes de imprimirmos isso, vamos realmente criar uma nova linha. Então diga M9, fim da principal, assim. Agora eu só vou mostrar a vocês como fazer isso no Visual Studio. Mas dito isso, eu recomendo acompanhar, independentemente você aprender algo ao longo do caminho, e dependendo do programa que você está usando para escrever seu código em C plus plus, você também deve ser capaz de fazer algo semelhante lá. E você simplesmente terá que pesquisar algumas diferenças e como criar os próprios arquivos. Agora, o que vamos fazer é ir até o nosso Solution Explorer à direita. E se você não ver isso, você pode ir até o topo aqui e clicar em Exibir e, em seguida, clicar em Solution Explorer. Então, tudo o que vamos fazer é clicar com o botão direito aqui e o Solution Explorer ir até Adicionar e, em seguida, clicar em novo item e clicar onde diz ponto CPP. E aqui embaixo, em vez da fonte, vamos digitar o nome da classe que queremos criar. Nesse caso, diremos minha classe e garantiremos que esteja escrito da mesma forma lá. Em seguida, vá em frente e clique em Adicionar. E agora você pode ver que nosso novo arquivo está aqui no topo. Em seguida, clicaremos com o botão direito do mouse em nosso explorador de soluções novamente, desceremos até Adicionar , clicaremos em novo item e iremos para onde diz arquivo de cabeçalho. E então mude o nome aqui para minha classe ponto h. E, mais uma vez, certifique-se de que esteja escrito corretamente e com a capitalização correta. Bem, eu acrescento novamente. E lá vamos nós. Então, se voltarmos ao nosso arquivo principal aqui e recortarmos tudo aqui, isso iria para o nosso arquivo de cabeçalho. Em seguida, vamos voltar ao nosso arquivo de cabeçalho, que é representado pela minha classe dot h e colá-lo lá. Em seguida, voltaremos ao nosso arquivo principal novamente e recortaremos nossas definições de classe. Vá até nosso arquivo CPP e cole-o lá também. E você notará instantaneamente que nosso arquivo CPP aqui não tem ideia de qual é a minha aula. E isso porque, assim como em nosso arquivo principal, onde incluímos esses arquivos de cabeçalho aqui, temos que fazer o mesmo e nosso arquivo CPP. Então, o que vamos fazer, eu digo hashtag. Esperançosamente. Então, sempre que você estiver trabalhando ou adicionando um arquivo de cabeçalho criado pelo usuário e não um que esteja embutido no C plus plus. Em vez do símbolo menor que e maior que, você usará aspas duplas assim. Então vamos dizer minha classe ponto h. Agora, você notará que ela não entende o que significa C out. E isso porque é parte de um, outro arquivo de cabeçalho. E se passarmos o mouse sobre isso, você pode ver que você pode pressionar Alt Enter para mostrar possíveis correções. E tudo o que eu quero fazer é incluir o arquivo iostream. Então, por favor, clique nele, será adicionado ali mesmo na parte superior. E ainda precisamos incluir de onde isso vem. Então, mais uma vez, podemos pressionar Alt, Enter no Visual Studio e adicionar std, seguido pelo operador de resolução de escopo e C out. Ou podemos fazer o que fizemos antes e adicionar isso usando namespace, std. Poderíamos ter digitado tudo isso manualmente, mas eu só queria mostrar a vocês que usam o Visual Studio. Outra forma de corrigir nosso código rapidamente. Então, se voltarmos ao nosso arquivo principal, podemos prosseguir e incluir nosso arquivo de cabeçalho da minha turma. Então, diremos que a hashtag inclui. Lembre-se de que vamos colocá-lo entre aspas. E, como você pode ver no Visual Studio nossas opções já aparecem aqui. Então, podemos simplesmente clicar duas vezes onde diz minha classe, ponto h, e eu imprimirei isso para nós. Então, aqui embaixo, podemos seguir em frente e criar um objeto ou uma instância da nossa classe. Então diga minha turma. Essa aula. E então, para acessar nossa função da minha classe, precisamos voltar ao nosso arquivo de cabeçalho e fazer essa função. Lembre-se de que vamos dizer público seguido por dois pontos e, em seguida, colocar nossa declaração de função abaixo disso. Então, se voltarmos ao nosso arquivo principal agora, podemos salvar essa classe de impressão de pontos trabalhando entre parênteses próximos e um ponto e vírgula no final. E agora, se executarmos um código, tudo funcionará bem. Como você pode ver, eu imprimi como trabalho e fim do principal. Agora, outra coisa que eu queria mencionar é que se você acabar fechando qualquer um desses arquivos por acidente. Então, digamos que eu feche o arquivo de cabeçalho em seu explorador de soluções. Abaixo dos arquivos de cabeçalho, você pode ver que está aqui. Basta clicar duas vezes nele e ele abrirá imediatamente. E então seu arquivo CPP está aqui embaixo, sob os arquivos de origem e nosso arquivo CPP principal, e também nos arquivos de origem. Uma última coisa que eu quero te mostrar é a seguinte. Se voltarmos ao nosso arquivo de cabeçalho aqui para minha aula, você pode ver que temos esse pragma de hashtag uma vez. O que isso faz é garantir que nosso arquivo de cabeçalho seja incluído apenas uma vez. E para mostrar exatamente o que isso faz, se voltarmos ao nosso arquivo principal aqui e copiarmos nosso arquivo de cabeçalho de inclusão e colarmos novamente e executarmos nosso código. Como você pode ver, funciona muito bem. E isso porque esse pragma de hashtag uma vez basicamente diz que, sempre que incluirmos nosso arquivo de cabeçalho aqui ou afirmamos que queremos incluí-lo, ele verificará se já o fez a declaração para minha classe, que, se você se lembrar, isso é tudo o que vai no seu arquivo de cabeçalho basicamente é aquela declaração para uma classe. E se isso acontecer, a declaração de inclusão é ignorada. E se isso não acontecer, adicionará a declaração. Então, a primeira vez que eu inseri e adicionei minha declaração de classe e a segunda vez que ela a ignorou. No entanto, nem todos os compiladores suportam essa diretiva pragma once aqui no topo. E eu não vou entrar no que os diretores são praticamente sempre que você vê esse símbolo de libra ou hashtag aqui, ou com essa hashtag ou libra incluída, é um tipo de diretiva. E, como eu disse, não vou entrar nisso, mas basicamente nem todos os compiladores os suportam. Então, vou mostrar uma alternativa e também vou mostrar o que aconteceria se não tivéssemos isso. Então, agora, se tentarmos executar nosso programa novamente, você verá que teremos um erro. Isso porque tentamos redefinir essa classe. Então, outra maneira de corrigir isso é com o que é chamado de idioma de guarda. E tudo o que precisamos fazer é, em nosso arquivo de cabeçalho dizer hashtag se N def e, abaixo, dizer hashtag define. E então, no final do nosso arquivo de cabeçalho, diremos hashtag. E no final de nossos f e f e definimos aqui, adicionaremos nosso nome de arquivo de cabeçalho sendo minha classe em maiúsculas. Então eu vou dizer que minha classe sublinhado e depois H. E essa é uma convenção de nomenclatura comum quando se trabalha com um protetor de cabeça e/ou uma coisa de idioma de guarda. O que temos aqui ou o pragma uma vez que você viu antes. Então, tudo o que você vai fazer é ter o nome do arquivo de cabeçalho em maiúsculas. E então, em vez de uma dieta, você vai ter um sublinhado. Então aqui em cima diz que minha turma ponto h aqui temos a idade do sublinhado da minha turma e todas em maiúsculas. Como eu disse, essa é apenas uma convenção de nomenclatura muito comum. Então faremos o mesmo depois para encontrar. Então, vamos ver o que isso significa. Agora, se seus compiladores suportam o pragma de hashtag que tínhamos antes, certo? Você pode simplesmente deixar isso no topo. No entanto, se isso não acontecer, esse é outro protetor de cabeçalho, o formato que você pode usar e que deve ser suportado. Então, vamos ver o que tudo isso significa. Então, primeiro temos essa hashtag F e F. Isso significa que, se não for definida, e o que estamos verificando? Se não estiver definido, esse arquivo de cabeçalho está aqui, e esse é o nome que estamos dando ao nosso arquivo de cabeçalho aqui. Essencialmente, você pode ver tudo o que foi aprovado nesta diretiva aqui como o corpo de nossa declaração if. Então, se meu arquivo de cabeçalho de classe não estiver definido, então queremos defini-lo. E aqui embaixo, precisamos terminar nossa declaração if. Mas em vez de terminar com um colchete fechado, vamos dizer hashtag e certo? E lembre-se de que isso é chamado de protetor de cabeçalho se você quiser investigar mais sobre isso. E, como eu disse antes, eles farão exatamente a mesma coisa que o pragma uma vez. Então, se o seu compilador suporta o site, Ótimo. Não basta adicionar o seguinte ao seu arquivo de cabeçalho. Limpe se N def seguido pelo nome do cabeçalho, então você dirá hashtag define com o mesmo nome logo abaixo. E então, no final, você vai dizer hashtag. E então lembre-se seu arquivo de cabeçalho inclui todas as suas declarações de classe, é por isso que eu disse no passado que queremos separar nossas declarações de nossas definições. E então, em nosso arquivo CPP, temos todas as nossas diretivas de inclusão. E eu sei que tenho chamado essas declarações durante todo o curso, mas elas são tecnicamente chamadas de diretivas. Então, você terá todas as suas diretivas de inclusão, qualquer uma usando namespaces que você queira usar e, em seguida, suas definições de classe. Em seguida, em seu arquivo principal, você precisa incluir o arquivo de cabeçalho da classe se quiser usar essa classe. E podemos adicionar quantos arquivos de cabeçalho e arquivos CPP precisarmos para dividir nosso código aqui. E lembre-se, tudo o que precisávamos fazer para fazer isso clicar no nome do nosso programa logo abaixo da solução aqui, botão direito do mouse, ir até Adicionar e, em seguida, novo item. Em seguida, adicionamos cada arquivo individualmente. E agora, embora tenhamos duas declarações do nosso arquivo de cabeçalho, assim como quando tínhamos nossa diretiva pragma once, nosso novo protetor de cabeçalho que acabamos de criar funcionará. Então, se o executarmos, você pode ver que isso funciona muito bem. Agora, em um programa pequeno, você provavelmente não adicionará acidentalmente seu arquivo de cabeçalho duas vezes ou tentará redefinir a classe duas vezes dessa forma. Mas quando você começa a trabalhar com programas muito maiores, eles definitivamente podem se tornar um problema. Então, você quer ter certeza de que pode evitar isso usando protetores de cabeçalho, usando a hashtag pragma uma vez, se o compilador suportar definido, ou você pode simplesmente usar a hashtag if e death. definição de hashtag e hashtag e F, como fizemos aqui. Então aí está. É assim que você pode dividir suas aulas em arquivos individuais. E isso também permitirá que você use suas aulas em outros programas. E espero que isso explique por que estamos separando nossas declarações de classe de nossas definições de classe, pois torna muito fácil simplesmente recortá-las separando nossas declarações de classe de nossas definições de classe, pois torna muito fácil simplesmente recortá-las e colá-las em arquivos separados, conforme necessário. E lembre-se de que tudo o que nosso protetor de cabeçalho fez foi nos permitir redeclarar acidentalmente nossa classe sem problemas. Então eu vou em frente e remover isso. Agora, existem alguns casos específicos em que você realmente não quer a guarda deles, mas na maioria das vezes você quer. E se você quiser saber quando não gostaria disso, sinta-se à vontade para fazer isso. Mas eu não vou falar sobre isso neste curso de qualquer maneira, é isso para este vídeo. Obrigado por assistir, e nos vemos na próxima. 101. Parabéns! : Parabéns por concluir este curso. Você deu um grande passo em sua jornada de programação e deve estar muito orgulhoso de tudo o que conquistou aqui. Se você gostou do curso ou o achou útil de alguma forma, agradeceríamos muito. Se você pudesse nos deixar um comentário positivo. Seu feedback não apenas nos ajuda a melhorar, mas também incentiva outras pessoas a iniciarem sua jornada aqui Agora, tente se lembrar de quando você começou. A ideia de codificar provavelmente foi avassaladora. Agora veja até onde você chegou. Você dominou os fundamentos, explorou tópicos avançados e adquiriu as habilidades para começar a criar seus Agora que você concluiu este curso, sua próxima etapa é colocar essas habilidades em prática. Uma ótima maneira de solidificar o que você aprendeu é realizar um projeto pequeno e gerenciável, algo que você possa concluir em duas a quatro E eu recomendo começar clonando um aplicativo simples existente para fins não comerciais, é claro E ao criar algo que já existe, você pode se concentrar em aprender como cada recurso funciona e como implementá-lo sozinho, em vez de projetá-lo do zero. E depois de fazer isso, tente adicionar seu toque único ou expandir o conceito como um segundo projeto É uma maneira fantástica de praticar e estimular sua criatividade e , ao mesmo tempo confiança em suas habilidades E então, a partir daí, você pode começar a se dedicar a projetos maiores, melhores e mais exclusivos. E lembre-se de que não há problema em voltar e revisitar o material do curso enquanto trabalha em seus próprios projetos Programar tem tudo a ver com aprender à medida que você avança. Até mesmo os desenvolvedores de temporadas pesquisam constantemente as coisas, seja para refrescar a memória ou resolver um novo problema Usar recursos como este curso ou a Internet não é uma fraqueza. É parte de ser um ótimo programador. Agora, isso é só o começo. Se você estava trabalhando em seu primeiro projeto, voltando para atualizar seus conhecimentos ou mergulhando em outro de nossos cursos, o conhecimento que você adquiriu aqui será seu trampolim para conquistas ainda maiores Falando nisso, não deixe de conferir nosso outro conteúdo para obter mais oportunidades de aprendizado. E se ainda não o fez, considere deixar nossa opinião para compartilhar sua experiência. Isso realmente faz a diferença, e adoraríamos ouvir você. De todos nós aqui da Primoris Arts, parabéns novamente por esse incrível marco podemos esperar para ver o que você criará a seguir, continuar aprendendo, mantendo a curiosidade e lembrando que o céu é o limite. Muito bem, e boa sorte em sua próxima aventura.